proteum 1.0.2 → 2.0.0-1

package/cli/compiler/server/index.ts

@@ -3,16 +3,12 @@
 ----------------------------------*/
 
 // Npm
-import webpack from 'webpack';
-import fs from 'fs-extra';
-
-// Minimizers
-const TerserPlugin = require("terser-webpack-plugin");
-//var VirtualModulesPlugin = require('webpack-virtual-modules');
+import { type Configuration } from '@rspack/core';
 
 // Core
 import cli from '@cli';
-import createCommonConfig, { TCompileMode, regex } from '../common';
+import createCommonConfig, { TCompileMode, TCompileOutputTarget, regex } from '../common';
+import { toRspackAliases } from '../common/rspackAliases';
 
 // Type
 import type { App } from '../../app';
@@ -35,45 +31,57 @@ import type { App } from '../../app';
 }*/
 
 const debug = false;
+const ssrScriptExtensions = ['.ssr.ts', '.ssr.tsx'];
+
+const getDevGeneratedRuntimeEntries = (app: App) => ({
+    __proteum_dev_routes: [app.paths.server.generated + '/routes.ts'],
+    __proteum_dev_controllers: [app.paths.server.generated + '/controllers.ts'],
+});
 
 /*----------------------------------
 - CONFIG
 ----------------------------------*/
-export default function createCompiler( app: App, mode: TCompileMode ): webpack.Configuration {
-
+export default function createCompiler(
+    app: App,
+    mode: TCompileMode,
+    outputTarget: TCompileOutputTarget = mode === 'dev' ? 'dev' : 'bin',
+): Configuration {
     debug && console.info(`Creating compiler for server (${mode}).`);
     const dev = mode === 'dev';
+    const outputPath = app.outputPath(outputTarget);
 
-    const commonConfig = createCommonConfig(app, 'server', mode);
-    const { aliases } = app.aliases.server.forWebpack({
-        modulesPath: app.paths.root + '/node_modules'
-    });
+    const commonConfig = createCommonConfig(app, 'server', mode, outputTarget);
+    const { aliases } = app.aliases.server.forWebpack({ modulesPath: app.paths.root + '/node_modules' });
 
     // We're not supposed in any case to import client services from server
-    delete aliases["@client/services"]; 
-    delete aliases["@/client/services"];
-
-    debug && console.log(`[${mode}] node_modules dirs:`, commonConfig.resolveLoader?.modules,
-        '\nModule aliases for webpack:', aliases);
-    const config: webpack.Configuration = {
-
+    delete aliases['@client/services'];
+    delete aliases['@/client/services'];
+    const rspackAliases = toRspackAliases(aliases);
+    rspackAliases['@/client/router$'] = cli.paths.core.root + '/client/router.ts';
+
+    debug &&
+        console.log(
+            `[${mode}] node_modules dirs:`,
+            commonConfig.resolveLoader?.modules,
+            '\nModule aliases for rspack:',
+            rspackAliases,
+        );
+    const config: Configuration = {
         ...commonConfig,
 
         name: 'server',
         target: 'node',
         entry: {
-            server: [
-                cli.paths.coreRoot + '/server/index.ts'
-            ],
+            server: [cli.paths.coreRoot + '/server/index.ts'],
+            ...(dev ? getDevGeneratedRuntimeEntries(app) : {}),
         },
 
         output: {
-
             pathinfo: dev,
 
             libraryTarget: 'commonjs2',
 
-            path: app.paths.bin,
+            path: outputPath,
             filename: '[name].js',
             publicPath: '/',
             assetModuleFilename: 'public/[hash][ext]',
@@ -82,38 +90,32 @@ export default function createCompiler( app: App, mode: TCompileMode ): webpack.
             // HMR
             hotUpdateMainFilename: 'updates/[fullhash].hot-update.json',
             hotUpdateChunkFilename: 'updates/[id].[fullhash].hot-update.js',
-
         },
 
         externalsPresets: { node: true }, // in order to ignore built-in modules like path, fs, etc.
         externals: [
-
-            './chunk-manifest.json',
-            './asset-manifest.json',
+            './client-manifest.json',
 
             // node_modules
             function ({ request }, callback) {
-
-                const shouldCompile = request !== undefined && (
+                const shouldCompile =
+                    request !== undefined &&
                     // Local files
-                    request[0] === '.' || request[0] === '/'
-                    ||
-                    // Aliased modules
-                    app.aliases.server.containsAlias(request)
-                    ||
-                    // TODO: proteum.conf: compile: include
-                    // Compile proteum modules
-                    request.startsWith('proteum')
-                    ||
-                    // Compile 5HTP modules
-                    request.startsWith('react-number-format') ||
-                    request.startsWith('@floating-ui')
-                )
+                    (request[0] === '.' ||
+                        request[0] === '/' ||
+                        // Aliased modules
+                        app.aliases.server.containsAlias(request) ||
+                        // TODO: proteum.conf: compile: include
+                        // Compile proteum modules
+                        request.startsWith('proteum') ||
+                        // Compile 5HTP modules
+                        request.startsWith('@mantine/') ||
+                        request.startsWith('react-number-format') ||
+                        request.startsWith('@floating-ui'));
 
                 //console.log('isNodeModule', request, isNodeModule);
 
                 if (!shouldCompile) {
-                    
                     // Externalize to a commonjs module using the request path
                     return callback(undefined, 'commonjs ' + request);
                 }
@@ -124,12 +126,12 @@ export default function createCompiler( app: App, mode: TCompileMode ): webpack.
         ],
 
         resolve: {
-
             ...commonConfig.resolve,
 
-            alias: aliases,
+            alias: rspackAliases,
 
-            extensions: ['.ts', '.tsx', ".json", ".sql", ".js"],
+            // Prefer SSR-specific variants on the server when imports stay extensionless.
+            extensions: [...ssrScriptExtensions, '.ts', '.tsx', '.json', '.sql', '.js'],
         },
 
         module: {
@@ -140,7 +142,6 @@ export default function createCompiler( app: App, mode: TCompileMode ): webpack.
                 {
                     test: regex.scripts,
                     include: [
-
                         app.paths.root + '/client',
                         cli.paths.core.root + '/client',
 
@@ -155,15 +156,12 @@ export default function createCompiler( app: App, mode: TCompileMode ): webpack.
                         // Temp disabled because compile issue on vercel
                         //...getCorePluginsList(app)
                     ],
-                    rules: require('../common/babel')(app, 'server', dev)
-                }, 
+                    rules: require('../common/scripts')({ app, side: 'server', dev }),
+                },
 
                 // Les pages étan tà la fois compilées dans le bundle client et serveur
                 // On ne compile les ressources (css) qu'une seule fois (coté client)
-                {
-                    test: regex.style,
-                    loader: 'null-loader'
-                },
+                { test: regex.style, loader: 'null-loader' },
 
                 ...require('../common/files/images')(app, dev, false),
 
@@ -179,33 +177,19 @@ export default function createCompiler( app: App, mode: TCompileMode ): webpack.
             ],
         },
 
-        plugins: [
-
-            ...(commonConfig.plugins || [])
-        ],
+        plugins: [...(commonConfig.plugins || [])],
 
-        optimization: {
-            minimizer: dev ? [] : [
-                new TerserPlugin({
-                    terserOptions: {
-                        // Consere les classnames
-                        //keep_classnames: true,
-                        //keep_fnames: true,
-                    }
-                }),
-            ]
-        },
+        optimization: { minimizer: [] },
 
-        // https://webpack.js.org/configuration/devtool/#devtool
-        devtool: dev 
-            ? 'eval-source-map' // Recommended choice for development builds with high quality SourceMaps.
+        devtool: dev
+            ? 'eval-cheap-module-source-map' // Cheaper than eval-source-map while keeping usable module-level stack traces.
             : 'source-map', // Recommended choice for production builds with high quality SourceMaps.
 
-            // eval-source-map n'est pas précis
+        // eval-source-map n'est pas précis
         /*devServer: {
             hot: true,
         },*/
     };
 
     return config;
-};
+}

package/cli/compiler/writeIfChanged.ts

@@ -0,0 +1,21 @@
+import path from 'path';
+import fs from 'fs-extra';
+
+const toBuffer = (content: string | Buffer) => (typeof content === 'string' ? Buffer.from(content) : content);
+
+export default function writeIfChanged(filepath: string, content: string | Buffer) {
+    const nextContent = toBuffer(content);
+    const dirpath = path.dirname(filepath);
+
+    fs.ensureDirSync(dirpath);
+
+    if (fs.existsSync(filepath)) {
+        const currentContent = fs.readFileSync(filepath);
+
+        if (currentContent.equals(nextContent)) return false;
+    }
+
+    fs.writeFileSync(filepath, nextContent);
+
+    return true;
+}

package/cli/index.ts

@@ -17,13 +17,9 @@ import Paths from './paths';
 - TYPES
 ----------------------------------*/
 
-type TCliCommand = () => Promise<{ 
-    run: () => Promise<void> 
-}>
+type TCliCommand = () => Promise<{ run: () => Promise<void> }>;
 
-type TArgsObject = {
-    [key: string]: string | boolean | string[]
-}
+type TArgsObject = { [key: string]: string | boolean | string[] };
 
 /*----------------------------------
 - CLASSE
@@ -32,17 +28,20 @@ type TArgsObject = {
     IMPORTANT: The CLI must be independant of the app instance and libs
 */
 export class CLI {
-
     // Context
     public args: TArgsObject = {};
-    
+
+    public commandOptionDefaults: { [command: string]: TArgsObject } = {
+        dev: { port: '', cache: true },
+        build: { port: '', dev: false, prod: false, cache: false, analyze: false },
+        lint: { fix: false },
+    };
+
     public debug: boolean = false;
 
-    public packageJson: {[key: string]: any};
+    public packageJson: { [key: string]: any };
 
-    public constructor(
-        public paths = new Paths( process.cwd() )
-    ) {
+    public constructor(public paths = new Paths(process.cwd())) {
         this.debug && console.log(`[cli] 5HTP CLI`, process.env.npm_package_version);
 
         this.debug && console.log(`[cli] Apply aliases ...`);
@@ -59,107 +58,111 @@ export class CLI {
     // Les importations asynchrones permettent d'accéder à l'instance de cli via un import
     // WARN: We load commands asynchonously, so the aliases are applied before the file is imported
     public commands: { [name: string]: TCliCommand } = {
-        "init": () => import('./commands/init'),
-        "dev": () => import('./commands/dev'),
-        "build": () => import('./commands/build'),
-    }
+        init: () => import('./commands/init'),
+        dev: () => import('./commands/dev'),
+        refresh: () => import('./commands/refresh'),
+        build: () => import('./commands/build'),
+        typecheck: () => import('./commands/typecheck'),
+        lint: () => import('./commands/lint'),
+        check: () => import('./commands/check'),
+    };
 
     private loadPkg() {
         return fs.readJSONSync(this.paths.core.root + '/package.json');
     }
 
     public start() {
-        
         const [, , commandName, ...argv] = process.argv;
 
-        if (this.commands[commandName] === undefined)
-            throw new Error(`Command ${commandName} does not exists.`);
+        if (this.commands[commandName] === undefined) throw new Error(`Command ${commandName} does not exists.`);
 
+        this.args = { ...(this.commandOptionDefaults[commandName] || {}) };
         this.args.workdir = process.cwd();
 
         let opt: string | null = null;
         for (const a of argv) {
+            if (a.startsWith('-')) {
+                opt = a.replace(/^-+/, '');
+                if (opt.length === 0) throw new Error(`Unknown option: ${a}`);
+
+                if (opt.startsWith('no-')) {
+                    const booleanOpt = opt.substring(3);
+                    if (!(booleanOpt in this.args)) throw new Error(`Unknown option: ${opt}`);
+                    if (typeof this.args[booleanOpt] !== 'boolean')
+                        throw new Error(`Option ${booleanOpt} does not support --no-${booleanOpt}.`);
 
-            if (a[0] === '-') {
+                    this.args[booleanOpt] = false;
+                    opt = null;
+                    continue;
+                }
 
-                opt = a.substring(1);
-                if (!(opt in this.args)) 
-                    throw new Error(`Unknown option: ${opt}`);
+                if (!(opt in this.args)) throw new Error(`Unknown option: ${opt}`);
 
                 // Init with default value
-                if (typeof this.args[opt] === "boolean")
+                if (typeof this.args[opt] === 'boolean') {
                     this.args[opt] = true;
-
+                    opt = null;
+                }
             } else if (opt !== null) {
-
                 const curVal = this.args[opt];
 
-                if (Array.isArray( curVal ))
-                    curVal.push(a);
-                else
-                    this.args[opt] = a;   
+                if (Array.isArray(curVal)) curVal.push(a);
+                else this.args[opt] = a;
 
                 opt = null;
-
             } else {
-
-                this.args[ a ] = true;
-
+                this.args[a] = true;
             }
         }
 
+        if (opt !== null && typeof this.args[opt] !== 'boolean') throw new Error(`Missing value for option: ${opt}`);
+
         this.runCommand(commandName);
     }
 
     public async runCommand(command: string) {
-
         this.debug && console.info(`Running command ${command}`, this.args);
 
         // Check existance
-        if (this.commands[command] === undefined)
-            throw new Error(`Command ${command} does not exists.`);
+        if (this.commands[command] === undefined) throw new Error(`Command ${command} does not exists.`);
 
         const runner = await this.commands[command]();
+        let exitCode = 0;
 
         // Running
-        runner.run().then(() => {
-
-            this.debug && console.info(`Command ${command} finished.`);
-
-        }).catch((e) => {
-
-            console.error(`Error during execution of ${command}:`, e);
-
-        }).finally(() => {
-
-            process.exit(0);
-
-        })
+        runner
+            .run()
+            .then(() => {
+                this.debug && console.info(`Command ${command} finished.`);
+            })
+            .catch((e) => {
+                exitCode = 1;
+                console.error(`Error during execution of ${command}:`, e);
+            })
+            .finally(() => {
+                process.exit(exitCode);
+            });
     }
 
-
     public shell(...commands: string[]) {
-
         return new Promise<void>(async (resolve) => {
+            const fullCommand = commands
+                .map((command) => {
+                    command = command.trim();
 
-            const fullCommand = commands.map(command => {
+                    if (command.endsWith(';')) command = command.substring(0, command.length - 1);
 
-                command = command.trim();
-
-                if (command.endsWith(';'))
-                    command = command.substring(0, command.length - 1);
-
-                return command;
-
-            }).join(';');
+                    return command;
+                })
+                .join(';');
 
             console.log('$ ' + fullCommand);
 
             /*const tempFile = this.paths.app.root + '/.exec.sh';
             fs.outputFileSync(tempFile, '#! /bin/bash\n' + fullCommand);
             const wrappedCommand =  `tilix --new-process -e bash -c 'chmod +x "${tempFile}"; "${tempFile}"; echo "Entrée pour continuer"; read a;'`;*/
-            const wrappedCommand =  `bash -c '${fullCommand}'`;
-            console.log("Running command: " + wrappedCommand)
+            const wrappedCommand = `bash -c '${fullCommand}'`;
+            console.log('Running command: ' + wrappedCommand);
             //await this.waitForInput('enter');
 
             const proc = cp.spawn(wrappedCommand, [], {
@@ -167,23 +170,19 @@ export class CLI {
                 detached: false,
                 // Permer de lancer les commandes via des chaines pures (autrement, il faut separer chaque arg dans un tableau)
                 // https://stackoverflow.com/questions/23487363/how-can-i-parse-a-string-into-appropriate-arguments-for-child-process-spawn
-                shell: true
+                shell: true,
             });
 
-            console.log( proc.exitCode );
+            console.log(proc.exitCode);
 
             proc.on('exit', function () {
-
                 //fs.removeSync(tempFile);
 
-                console.log("Command finished.");
+                console.log('Command finished.');
                 resolve();
-            })
-
+            });
         });
-        
     }
-
 }
 
-export default new CLI()
+export default new CLI();