meocord 3.2.2 → 4.0.0-beta.1

package/dist/esm/bin/helper/service-generator.helper.js

@@ -1,7 +1,7 @@
 import path from 'path';
 import { Logger } from '../../common/logger.js';
 import '../../common/theme.js';
-import { validateAndFormatName, buildTemplate, createDirectoryIfNotExists, generateFile } from '../../util/generator-cli.util.js';
+import { validateAndFormatName, assertFilesAbsent, buildTemplate, createDirectoryIfNotExists, generateFile } from '../../util/generator-cli.util.js';
 
 class ServiceGeneratorHelper {
     /**
@@ -20,13 +20,19 @@ class ServiceGeneratorHelper {
         const { parts, kebabCaseName, className } = validateAndFormatName(serviceName);
         const serviceDir = path.join(process.cwd(), 'src', 'services', ...parts);
         const serviceFile = path.join(serviceDir, `${kebabCaseName}.service.ts`);
+        const specFile = path.join(serviceDir, `${kebabCaseName}.service.spec.ts`);
+        // Both files checked before either is written, so an existing service is never replaced.
+        assertFilesAbsent([
+            serviceFile,
+            specFile
+        ]);
         const serviceTemplate = buildTemplate(className, 'service.template');
         const specTemplate = buildTemplate(className, 'service.spec.template', {
             kebabCaseName
         });
         createDirectoryIfNotExists(serviceDir);
         generateFile(serviceFile, serviceTemplate);
-        generateFile(path.join(serviceDir, `${kebabCaseName}.service.spec.ts`), specTemplate);
+        generateFile(specFile, specTemplate);
     }
     constructor(appName){
         this.appName = appName;

package/dist/esm/bin/meocord.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import path from 'path';
-import webpack from 'webpack';
+import { createRsbuild } from '@rsbuild/core';
 import { Logger } from '../common/logger.js';
 import '../common/theme.js';
 import { spawn } from 'node:child_process';
@@ -10,7 +10,6 @@ import { GeneratorCLI } from './generator.js';
 import { runtimePrefixFor, AppGeneratorHelper } from './helper/app-generator.helper.js';
 import * as fs from 'node:fs';
 import { setEnvironment, compileAndValidateConfig, validateDiscordToken } from '../util/common.util.js';
-import { prepareModifiedTsConfig } from '../util/tsconfig.util.js';
 import { Command } from 'commander';
 import { simpleGit } from 'simple-git';
 import { execSync } from 'child_process';
@@ -21,8 +20,10 @@ import { resolveOwnVersion } from '../util/package-version.util.js';
 import { buildAppCommand, resolveRuntime } from '../util/runtime.util.js';
 import packageJson from '../package.json.js';
 import { fileURLToPath } from 'url';
-import TsconfigPathsPlugin from 'tsconfig-paths-webpack-plugin';
-import nodeExternals from 'webpack-node-externals';
+import { assertNoWebpackHook, createRsbuildConfig, DISCORD_OPTIONAL_NATIVES } from '../build/rsbuild-config.js';
+import { createNativeExternals, nativeCarrier, copyPackagesInto, bundledModuleFiles, assertNoBundledNativeAddons, findBundledNativeAddons } from '../build/native-addons.js';
+import { writePlatformManifest, PLATFORM_MANIFEST } from '../util/platform.util.js';
+import { loadMeoCordSourceConfig } from '../util/meocord-source-config.util.js';
 
 const __filename$1 = fileURLToPath(import.meta.url);
 const __dirname$1 = path.dirname(__filename$1);
@@ -216,6 +217,91 @@ copies or substantial portions of the Software.
         p.outro(`MeoCord app "${kebabCaseAppName}" is ready!`);
     }
     /**
+   * Builds the bundler configuration for this project and creates an Rsbuild instance.
+   *
+   * The base configuration comes from {@link createRsbuildConfig}; the application's
+   * `rsbuild` hook, if it declares one, is given the chance to modify it.
+   */ async createBundler(mode) {
+        // Read from source on every build: the compiled copy in dist is the previous build's.
+        const meocordConfig = loadMeoCordSourceConfig();
+        assertNoWebpackHook(meocordConfig);
+        const base = createRsbuildConfig({
+            mode,
+            bundleDependencies: meocordConfig?.bundleDependencies,
+            externals: meocordConfig?.externals
+        });
+        const config = meocordConfig?.rsbuild?.(base) ?? base;
+        // A native addon cannot be inlined into JavaScript, so when bundling, each one is kept out of
+        // the bundle as the bundler meets it and recorded for build() to copy into dist. Added after
+        // the application's hook, so a hook that sets externals of its own does not drop it.
+        const natives = meocordConfig?.bundleDependencies ? createNativeExternals(this.projectRoot) : undefined;
+        if (natives) {
+            var _config;
+            (_config = config).output ?? (_config.output = {});
+            const existing = config.output.externals;
+            config.output.externals = [
+                ...Array.isArray(existing) ? existing : existing ? [
+                    existing
+                ] : [],
+                natives.externals
+            ];
+        }
+        const rsbuild = await createRsbuild({
+            cwd: this.projectRoot,
+            config
+        });
+        return {
+            rsbuild,
+            meocordConfig,
+            natives
+        };
+    }
+    /**
+   * Makes a bundled build's dist runnable on its own: copies every package the bundle still
+   * imports -- the native addons found while building, anything listed in `externals`, and
+   * discord.js's optional accelerators if they are installed -- into `dist/node_modules`, and
+   * marks dist as ESM. Deploying is then copying dist, with no install step.
+   */ packDependencies(meocordConfig, natives) {
+        const dist = path.join(this.projectRoot, 'dist');
+        const packages = new Map([
+            ...natives
+        ].map(([name, { dir }])=>[
+                name,
+                dir
+            ]));
+        const nativeNames = new Set(natives.keys());
+        const listed = (meocordConfig.externals ?? []).filter((item)=>typeof item === 'string');
+        for (const name of [
+            ...listed,
+            ...DISCORD_OPTIONAL_NATIVES
+        ]){
+            const dir = path.join(this.projectRoot, 'node_modules', name);
+            if (packages.has(name) || !fs.existsSync(path.join(dir, 'package.json'))) continue;
+            packages.set(name, dir);
+            if (nativeCarrier(dir, name, this.projectRoot)) nativeNames.add(name);
+        }
+        // Replaced rather than merged, so a package dropped from the application does not linger.
+        fs.rmSync(path.join(dist, 'node_modules'), {
+            recursive: true,
+            force: true
+        });
+        const copied = copyPackagesInto(packages, this.projectRoot, dist);
+        fs.writeFileSync(path.join(dist, 'package.json'), `${JSON.stringify({
+            type: 'module'
+        }, null, 2)}\n`);
+        if (nativeNames.size > 0) {
+            writePlatformManifest(dist);
+            this.logger.info(`Native addons packed into dist: ${[
+                ...nativeNames
+            ].join(', ')}`);
+        } else {
+            fs.rmSync(path.join(dist, PLATFORM_MANIFEST), {
+                force: true
+            });
+        }
+        if (copied.length > 0) this.logger.info(`dist/node_modules holds ${copied.length} packages; nothing else to install.`);
+    }
+    /**
    * Builds the MeoCord application in the specified mode.
    *
    * @param mode - The build mode ('production' or 'development').
@@ -223,45 +309,21 @@ copies or substantial portions of the Software.
         try {
             this.clearConsole();
             this.logger.info(`Building ${mode} version...`);
-            const webpackConfig = (await import(this.webpackConfigPath)).default;
-            const compiler = webpack({
-                ...webpackConfig,
-                mode
-            });
-            if (!compiler) {
-                this.logger.error('Failed to create webpack compiler instance.');
-                throw new Error('Failed to create webpack compiler instance.');
-            }
-            // Workaround for Bun: Keep the event loop alive while webpack runs
-            // Bun sometimes exits before async callbacks fire
-            let keepAliveTimer = null;
-            await new Promise((resolve, reject)=>{
-                keepAliveTimer = setInterval(()=>{
-                // Keeps event loop active
-                }, 100);
-                compiler.run((err, stats)=>{
-                    if (keepAliveTimer) {
-                        clearInterval(keepAliveTimer);
-                        keepAliveTimer = null;
-                    }
-                    if (err) {
-                        this.logger.error(`Build encountered an error: ${err.message}`);
-                        return reject(`Build encountered an error: ${err.message}`);
-                    }
-                    if (stats?.hasErrors()) {
-                        this.logger.error('Build failed due to errors in the compilation process:', stats.compilation.errors);
-                    } else {
-                        this.logger.info(`${capitalize(mode)} build completed successfully.`);
-                    }
-                    compiler.close((closeErr)=>{
-                        if (closeErr) {
-                            this.logger.error(`Error occurred while closing the compiler: ${closeErr.message}`);
-                            return reject(`Error occurred while closing the compiler: ${closeErr.message}`);
-                        }
-                        resolve();
-                    });
+            const { rsbuild, meocordConfig, natives } = await this.createBundler(mode);
+            const bundledFiles = [];
+            if (meocordConfig?.bundleDependencies) {
+                rsbuild.onAfterBuild(({ stats })=>{
+                    bundledFiles.push(...bundledModuleFiles(stats));
                 });
-            });
+            }
+            await rsbuild.build();
+            if (meocordConfig?.bundleDependencies && natives) {
+                // A safety net behind the externals function: a native addon that still reached the
+                // bundle would run on this machine -- through its node_modules -- and fail in production.
+                assertNoBundledNativeAddons(findBundledNativeAddons(bundledFiles, this.projectRoot));
+                this.packDependencies(meocordConfig, natives.found);
+            }
+            this.logger.info(`${capitalize(mode)} build completed successfully.`);
         } catch (error) {
             this.logger.error(`Build process failed: ${error.message}`);
             await wait(100);
@@ -275,84 +337,54 @@ copies or substantial portions of the Software.
         const configPath = path.resolve(this.projectRoot, 'meocord.config.ts');
         if (!fs.existsSync(configPath)) return;
         try {
-            const tsConfigPath = prepareModifiedTsConfig();
-            const compiler = webpack({
+            // Deliberately built without the application's `rsbuild` hook: this compiles the very
+            // file that declares that hook, so applying it here would let a config shape its own
+            // compilation. It does follow `bundleDependencies`, though: the config imports packages
+            // too (dotenv, usually), and a bot bundled to run without node_modules would otherwise
+            // fail on its own config file.
+            const meocordConfig = loadMeoCordSourceConfig();
+            const bundleDependencies = meocordConfig?.bundleDependencies ?? false;
+            const base = createRsbuildConfig({
+                mode: 'development',
                 entry: configPath,
-                target: 'node',
-                mode: 'none',
-                externals: [
-                    nodeExternals({
-                        importType: 'module'
-                    })
-                ],
-                module: {
-                    rules: [
-                        {
-                            test: /\.ts$/,
-                            use: {
-                                loader: 'swc-loader',
-                                options: {
-                                    jsc: {
-                                        parser: {
-                                            syntax: 'typescript',
-                                            tsx: false,
-                                            decorators: true
-                                        },
-                                        transform: {
-                                            decoratorMetadata: true,
-                                            legacyDecorator: true
-                                        }
-                                    }
-                                }
-                            },
-                            exclude: /node_modules/
+                bundleDependencies,
+                externals: meocordConfig?.externals
+            });
+            const rsbuild = await createRsbuild({
+                cwd: this.projectRoot,
+                config: {
+                    ...base,
+                    source: {
+                        ...base.source,
+                        entry: {
+                            'meocord.config': configPath
                         }
-                    ]
-                },
-                resolve: {
-                    extensions: [
-                        '.ts',
-                        '.js'
-                    ],
-                    plugins: [
-                        new TsconfigPathsPlugin({
-                            configFile: tsConfigPath
-                        })
-                    ]
-                },
-                output: {
-                    filename: 'meocord.config.mjs',
-                    path: path.resolve(this.projectRoot, 'dist'),
-                    library: {
-                        type: 'module'
+                    },
+                    output: {
+                        ...base.output,
+                        distPath: {
+                            root: path.resolve(this.projectRoot, 'dist'),
+                            js: ''
+                        },
+                        filename: {
+                            js: '[name].mjs'
+                        },
+                        minify: {
+                            js: false
+                        },
+                        sourceMap: false,
+                        // Runs beside the application build in the same dist; cleaning would delete it.
+                        cleanDistPath: false
                     }
-                },
-                experiments: {
-                    outputModule: true
-                },
-                optimization: {
-                    minimize: false
                 }
             });
-            await new Promise((resolve)=>{
-                compiler.run((err, stats)=>{
-                    if (err || stats?.hasErrors()) {
-                        this.logger.warn('Failed to compile meocord.config.ts — runtime will fall back to source config.');
-                        resolve();
-                        return;
-                    }
-                    compiler.close((closeErr)=>{
-                        if (closeErr) {
-                            resolve();
-                            return;
-                        }
-                        this.logger.info('Config compiled to dist/meocord.config.mjs');
-                        resolve();
-                    });
-                });
-            });
-        } catch  {
-            this.logger.warn('Failed to compile meocord.config.ts — runtime will fall back to source config.');
+            await rsbuild.build();
+            this.logger.info('Config compiled to dist/meocord.config.mjs');
+        } catch (error) {
+            // The built application reads only the compiled config, so without it the bot cannot start.
+            this.logger.error(`Failed to compile meocord.config.ts: ${error instanceof Error ? error.message : error}`);
+            await wait(100);
+            process.exit(1);
         }
     }
     /**
@@ -396,30 +428,22 @@ copies or substantial portions of the Software.
             this.clearConsole();
             this.logger.log('Starting watch mode...');
             await this.compileConfig();
-            const webpackConfig = (await import(this.webpackConfigPath)).default;
-            const compiler = webpack({
-                ...webpackConfig,
-                mode: 'development'
-            });
-            if (!compiler) {
-                this.logger.error('Failed to create webpack compiler instance.');
-                await wait(100);
-                process.exit(1);
-            }
             let isRunning = false;
-            const watch = ()=>compiler.watch({}, (err, stats)=>{
-                    if (err) {
-                        this.logger.error(`Webpack Error: ${err.message}`);
-                        return;
-                    }
-                    if (stats?.hasErrors()) {
-                        this.logger.error('Build failed due to errors in the compilation process:', stats.compilation.errors);
-                    } else {
-                        this.restartApp();
-                        isRunning = true;
-                    }
+            let watching;
+            const watch = async ()=>{
+                const { rsbuild } = await this.createBundler('development');
+                // Runs after every rebuild, which is where the application is restarted. A failed
+                // rebuild reports its own errors and does not reach here, so the process already
+                // running is left alone rather than being replaced by a broken build.
+                rsbuild.onAfterBuild(()=>{
+                    this.restartApp();
+                    isRunning = true;
+                });
+                watching = await rsbuild.build({
+                    watch: true
                 });
-            watch();
+            };
+            await watch();
             let debounceWatcher;
             const fsWatcher = fs.watch(path.resolve(process.cwd(), 'meocord.config.ts'), ()=>{
                 clearTimeout(debounceWatcher);
@@ -431,8 +455,8 @@ copies or substantial portions of the Software.
                             this.appProcess.kill();
                             this.appProcess = null;
                         }
-                        await new Promise((resolve)=>compiler.close(resolve));
-                        watch();
+                        await watching?.close();
+                        await watch();
                     }
                 }, 300);
             });
@@ -449,11 +473,11 @@ copies or substantial portions of the Software.
                 fsWatcher.close();
                 if (this.appProcess && !this.appProcess.killed) {
                     this.appProcess.on('exit', async ()=>{
-                        await new Promise((resolve)=>compiler.close(resolve));
+                        await watching?.close();
                         process.exit(0);
                     });
                 } else {
-                    await new Promise((resolve)=>compiler.close(resolve));
+                    await watching?.close();
                     process.exit(0);
                 }
             });
@@ -518,7 +542,6 @@ copies or substantial portions of the Software.
         this.logger = new Logger(this.appName);
         this.projectRoot = process.cwd();
         this.mainJSPath = path.join(this.projectRoot, 'dist', 'main.js');
-        this.webpackConfigPath = path.resolve(__dirname$1, '..', '..', '..', 'webpack.config.js');
         this.generatorCLI = new GeneratorCLI(this.appName);
         this.appGeneratorHelper = new AppGeneratorHelper();
         this.version = resolveOwnVersion(__dirname$1, packageJson.version);