meocord 3.2.2 → 4.0.0-beta.0

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-config-loader.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,82 +337,49 @@ 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();
-                    });
-                });
-            });
+            await rsbuild.build();
+            this.logger.info('Config compiled to dist/meocord.config.mjs');
         } catch  {
             this.logger.warn('Failed to compile meocord.config.ts — runtime will fall back to source config.');
         }
@@ -396,30 +425,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 +452,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 +470,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 +539,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);

package/dist/esm/build/native-addons.js

@@ -0,0 +1,235 @@
+import { readdirSync, readFileSync, existsSync, cpSync } from 'fs';
+import path from 'path';
+
+/**
+ * The package a resolved module file belongs to, and the directory it was installed in.
+ *
+ * Takes the innermost `node_modules` segment, so a nested copy is attributed to itself rather
+ * than to the package it is nested under. Undefined for application code.
+ */ function packageFromPath(file) {
+    // A module identifier can carry loaders before the resource (`loader!/path/to/file`) and a
+    // query after it; only the path itself says where the package lives.
+    const resource = file.slice(file.lastIndexOf('!') + 1).split('?')[0];
+    const segments = resource.split(/[\\/]/);
+    const index = segments.lastIndexOf('node_modules');
+    if (index === -1 || index + 1 >= segments.length) return undefined;
+    const scoped = segments[index + 1].startsWith('@');
+    if (scoped && index + 2 >= segments.length) return undefined;
+    const end = index + (scoped ? 3 : 2);
+    return {
+        name: segments.slice(index + 1, end).join('/'),
+        dir: segments.slice(0, end).join(path.sep)
+    };
+}
+/**
+ * Every source file a build pulled into its output.
+ *
+ * Concatenated modules nest their members, and a multi-environment build nests whole
+ * compilations as children, so both are walked.
+ */ function bundledModuleFiles(stats) {
+    if (!stats) return [];
+    const json = stats.toJson({
+        all: false,
+        modules: true,
+        nestedModules: true,
+        // A production build concatenates most of node_modules into a few modules, and the members
+        // of a concatenation are orphans -- hidden from stats unless asked for. Without this every
+        // concatenated package, sharp included, was invisible here.
+        orphanModules: true,
+        modulesSpace: Infinity,
+        nestedModulesSpace: Infinity
+    });
+    const collect = (modules)=>(modules ?? []).flatMap((module)=>[
+                module.nameForCondition ?? module.identifier ?? '',
+                ...collect(module.modules),
+                // Stats may group modules by path, nesting them under `children`.
+                ...collect(module.children)
+            ]);
+    const compilations = json.children?.length ? json.children : [
+        json
+    ];
+    return compilations.flatMap((compilation)=>collect(compilation.modules)).filter(Boolean);
+}
+/** Whether a directory holds a compiled addon, not counting packages nested inside it. */ function containsNativeBinary(dir, depth = 0) {
+    if (depth > 5) return false;
+    let entries;
+    try {
+        entries = readdirSync(dir, {
+            withFileTypes: true
+        });
+    } catch  {
+        return false;
+    }
+    return entries.some((entry)=>{
+        if (entry.isFile()) return entry.name.endsWith('.node');
+        if (!entry.isDirectory() || entry.name === 'node_modules') return false;
+        return containsNativeBinary(path.join(dir, entry.name), depth + 1);
+    });
+}
+/**
+ * Where an optional dependency of the package in `from` was installed, if it was.
+ *
+ * Nested under the package, beside it (pnpm's layout, and npm's hoisting within a scope), or
+ * hoisted to the project root. A platform package that did not match this machine is not
+ * installed at all, which is how only the right binary is found.
+ */ function resolveDependencyDir(name, from, root) {
+    const candidates = [
+        path.join(from, 'node_modules', name),
+        path.join(path.dirname(from), name),
+        path.join(path.dirname(path.dirname(from)), name),
+        path.join(root, 'node_modules', name)
+    ];
+    return candidates.find((dir)=>existsSync(path.join(dir, 'package.json')));
+}
+/** A package's declared dependencies, runtime and optional, or none if it cannot be read. */ function readDependencies(dir) {
+    try {
+        const pkg = JSON.parse(readFileSync(path.join(dir, 'package.json'), 'utf8'));
+        return {
+            dependencies: Object.keys(pkg.dependencies ?? {}),
+            optional: Object.keys(pkg.optionalDependencies ?? {})
+        };
+    } catch  {
+        return {
+            dependencies: [],
+            optional: []
+        };
+    }
+}
+/**
+ * The package holding the compiled addon an installed package loads, or undefined for plain
+ * JavaScript.
+ *
+ * The binary is rarely in the package that gets imported. node-gyp packages keep it in their own
+ * directory, under `build/Release`. napi-rs packages and sharp ship a JavaScript loader and publish
+ * each platform's binary as a separate package, declared as an optional dependency so only the
+ * matching one installs. Both layouts are checked.
+ */ function nativeCarrier(dir, name, root) {
+    if (containsNativeBinary(dir)) return name;
+    return readDependencies(dir).optional.find((dependency)=>{
+        const dependencyDir = resolveDependencyDir(dependency, dir, root);
+        return dependencyDir !== undefined && containsNativeBinary(dependencyDir);
+    });
+}
+/** Bundled packages that load a native addon, mapped to the package holding the binary. */ function findBundledNativeAddons(bundledFiles, root) {
+    const packages = new Map();
+    for (const file of bundledFiles){
+        const found = packageFromPath(file);
+        if (found && !packages.has(found.dir)) packages.set(found.dir, found.name);
+    }
+    const natives = new Map();
+    for (const [dir, name] of packages){
+        if (natives.has(name)) continue;
+        const carrier = nativeCarrier(dir, name, root);
+        if (carrier) natives.set(name, carrier);
+    }
+    return natives;
+}
+/**
+ * The package a bare import request names, or undefined for a relative path, an absolute path, or
+ * a Node builtin -- none of which live in node_modules.
+ */ function packageNameOfRequest(request) {
+    if (!request || request.startsWith('.') || request.startsWith('/') || /^[a-z]+:/i.test(request)) return undefined;
+    if (/^[A-Za-z]:[\\/]/.test(request)) return undefined;
+    const [first, second] = request.split('/');
+    if (!first.startsWith('@')) return first;
+    return second ? `${first}/${second}` : undefined;
+}
+/** Where `name` resolves from `context` the way Node would: the nearest node_modules walking up. */ function resolveInstalledPackage(name, context, root) {
+    let dir = context;
+    for(;;){
+        const candidate = path.join(dir, 'node_modules', name);
+        if (existsSync(path.join(candidate, 'package.json'))) return candidate;
+        const parent = path.dirname(dir);
+        if (parent === dir) break;
+        dir = parent;
+    }
+    const hoisted = path.join(root, 'node_modules', name);
+    return existsSync(path.join(hoisted, 'package.json')) ? hoisted : undefined;
+}
+/**
+ * An Rspack `externals` function that keeps every native addon out of the bundle.
+ *
+ * Decided while the bundler resolves imports, so it sees every request -- including one made by a
+ * plain JavaScript dependency deep in the graph -- and never has to be told what to look for. Each
+ * native package it keeps out is recorded in `found`, so the build can copy it into the output.
+ */ function createNativeExternals(root) {
+    const found = new Map();
+    const plain = new Set();
+    const externals = ({ request, context }, callback)=>{
+        const name = request ? packageNameOfRequest(request) : undefined;
+        if (!name || plain.has(name)) return callback();
+        if (found.has(name)) return callback(undefined, request);
+        const dir = resolveInstalledPackage(name, context ?? root, root);
+        const carrier = dir ? nativeCarrier(dir, name, root) : undefined;
+        if (!dir || !carrier) {
+            plain.add(name);
+            return callback();
+        }
+        found.set(name, {
+            dir,
+            carrier
+        });
+        callback(undefined, request);
+    };
+    return {
+        externals,
+        found
+    };
+}
+/**
+ * Copies packages, with everything they need at runtime, into `<outDir>/node_modules`.
+ *
+ * This is what lets a bundled application run with nothing installed beside it: the packages that
+ * could not be bundled travel inside the output directory, where Node finds them by walking up
+ * from the bundle. Each package's installed dependencies and optional dependencies are followed --
+ * that is where a platform binary lives -- and one not installed for this platform is skipped.
+ * Type-only `@types` packages are left behind; some packages list them as runtime dependencies,
+ * and they only add weight.
+ *
+ * @returns The names copied.
+ */ function copyPackagesInto(packages, root, outDir) {
+    const copied = new Set();
+    const copy = (name, dir)=>{
+        if (copied.has(name) || name.startsWith('@types/')) return;
+        copied.add(name);
+        const target = path.join(outDir, 'node_modules', name);
+        // A package's own nested node_modules comes along with it, so only hoisted dependencies
+        // need finding separately.
+        cpSync(dir, target, {
+            recursive: true,
+            dereference: true
+        });
+        const { dependencies, optional } = readDependencies(dir);
+        for (const dependency of [
+            ...dependencies,
+            ...optional
+        ]){
+            if (existsSync(path.join(dir, 'node_modules', dependency, 'package.json'))) continue;
+            const dependencyDir = resolveDependencyDir(dependency, dir, root);
+            if (dependencyDir) copy(dependency, dependencyDir);
+        }
+    };
+    for (const [name, dir] of packages)copy(name, dir);
+    return [
+        ...copied
+    ];
+}
+/**
+ * Refuses a bundled build that swallowed a native addon.
+ *
+ * Such a build does not fail on its own. It succeeds, the bot starts, and on the build machine it
+ * even works, because the bundle resolves the addon back into that machine's node_modules by
+ * absolute path. Anywhere else it fails the first time the addon loads -- often a command, long
+ * after startup. Failing the build is the only point this can be caught.
+ */ function assertNoBundledNativeAddons(found) {
+    if (found.size === 0) return;
+    const lines = [
+        ...found
+    ].map(([bundled, carrier])=>carrier === bundled ? `  - ${bundled}` : `  - ${bundled} (its binary ships in ${carrier})`);
+    const names = [
+        ...found.keys()
+    ].map((name)=>`'${name}'`).join(', ');
+    throw new Error(`bundleDependencies bundled ${found.size === 1 ? 'a package that loads' : 'packages that load'} a native addon:\n` + `${lines.join('\n')}\n` + 'A native addon is a compiled binary for one platform and cannot travel inside the bundle. The build ' + 'would run on this machine and fail in production the first time the addon loads. Keep ' + `${found.size === 1 ? 'it' : 'them'} out of the bundle and install ${found.size === 1 ? 'it' : 'them'} ` + `on the server:\n\n  externals: [${names}]`);
+}
+
+export { assertNoBundledNativeAddons, bundledModuleFiles, copyPackagesInto, createNativeExternals, findBundledNativeAddons, nativeCarrier, packageFromPath, packageNameOfRequest };