@bleedingdev/modern-js-server 3.2.0-ultramodern.0

package/dist/esm/dev-tools/watcher/dependencyTree.mjs

@@ -0,0 +1,57 @@
+import * as __rspack_external_minimatch from "minimatch";
+const defaultIgnores = [
+    '**/coverage/**',
+    '**/node_modules/**',
+    '**/.*/**',
+    '**/*.d.ts',
+    '**/*.log'
+];
+class DependencyTree {
+    getNode(path) {
+        return this.tree.get(path);
+    }
+    update(cache) {
+        this.tree.clear();
+        Object.keys(cache).forEach((path)=>{
+            if (!this.shouldIgnore(path)) {
+                const module = cache[path];
+                this.tree.set(module.filename, {
+                    module,
+                    parent: new Set(),
+                    children: new Set()
+                });
+            }
+        });
+        for (const treeNode of this.tree.values()){
+            const { parent } = treeNode.module;
+            const { children } = treeNode.module;
+            if (parent && !this.shouldIgnore(parent.filename)) {
+                const parentTreeNode = this.tree.get(parent.filename);
+                if (parentTreeNode) treeNode.parent.add(parentTreeNode);
+            }
+            children?.forEach((child)=>{
+                if (!this.shouldIgnore(child.filename)) {
+                    const childTreeNode = this.tree.get(child.filename);
+                    if (childTreeNode) {
+                        treeNode.children.add(childTreeNode);
+                        childTreeNode.parent.add(treeNode);
+                    }
+                }
+            });
+        }
+    }
+    shouldIgnore(path) {
+        return !path || Boolean(this.ignore.find((rule)=>__rspack_external_minimatch.match([
+                path
+            ], rule, {
+                dot: true
+            }).length > 0));
+    }
+    constructor(){
+        this.tree = new Map();
+        this.ignore = [
+            ...defaultIgnores
+        ];
+    }
+}
+export { DependencyTree, defaultIgnores };

package/dist/esm/dev-tools/watcher/index.mjs

@@ -0,0 +1,91 @@
+import { chokidar, fs } from "@modern-js/utils";
+import path from "path";
+import { DependencyTree } from "./dependencyTree.mjs";
+import { StatsCache } from "./statsCache.mjs";
+const defaultWatchOptions = {
+    ignoreInitial: true,
+    ignored: /api\/typings\/.*/
+};
+const getWatchedFiles = (watcher)=>{
+    const watched = watcher.getWatched();
+    const files = [];
+    Object.keys(watched).forEach((dir)=>{
+        const dirFiles = watched[dir];
+        if (!dirFiles) return;
+        dirFiles.forEach((fileName)=>{
+            files.push(path.join(dir, fileName));
+        });
+    });
+    return files;
+};
+const mergeWatchOptions = (options)=>{
+    const watchOptions = {
+        ...options
+    };
+    if (watchOptions) {
+        const { ignored } = watchOptions;
+        const finalIgnored = ignored ? [
+            defaultWatchOptions.ignored,
+            ...Array.isArray(ignored) ? ignored : [
+                ignored
+            ]
+        ] : ignored;
+        if (finalIgnored) watchOptions.ignored = finalIgnored;
+    }
+    const finalWatchOptions = {
+        ...defaultWatchOptions,
+        ...watchOptions
+    };
+    return finalWatchOptions;
+};
+class Watcher {
+    listen(files, options, callback) {
+        const watched = files.filter(Boolean);
+        const filenames = watched.map((filename)=>filename.replace(/\\/g, '/'));
+        const cache = new StatsCache();
+        const watcher = chokidar.watch(filenames, options);
+        watcher.on('ready', ()=>{
+            cache.add(getWatchedFiles(watcher));
+        });
+        watcher.on('change', (changed)=>{
+            if (!fs.existsSync(changed) || cache.isDiff(changed)) {
+                cache.refresh(changed);
+                callback(changed, 'change');
+            }
+        });
+        watcher.on('add', (changed)=>{
+            if (!cache.has(changed)) {
+                cache.add([
+                    changed
+                ]);
+                callback(changed, 'add');
+            }
+        });
+        watcher.on('unlink', (changed)=>{
+            cache.del(changed);
+            callback(changed, 'unlink');
+        });
+        this.watcher = watcher;
+    }
+    createDepTree() {
+        this.dependencyTree = new DependencyTree();
+    }
+    updateDepTree() {
+        this.dependencyTree?.update(require.cache);
+    }
+    cleanDepCache(filepath) {
+        const node = this.dependencyTree?.getNode(filepath);
+        if (node && require.cache[filepath]) {
+            delete require.cache[filepath];
+            for (const parentNode of node.parent.values())this.cleanDepCache(parentNode.module.filename);
+        }
+    }
+    close() {
+        return this.watcher.close();
+    }
+    constructor(){
+        this.dependencyTree = null;
+    }
+}
+export default Watcher;
+export { defaultWatchOptions, getWatchedFiles, mergeWatchOptions };

package/dist/esm/dev-tools/watcher/statsCache.mjs

@@ -0,0 +1,50 @@
+import crypto_0 from "crypto";
+import fs from "fs";
+class StatsCache {
+    add(files) {
+        const { cachedHash, cachedSize } = this;
+        for (const filename of files)if (fs.existsSync(filename)) {
+            const stats = fs.statSync(filename);
+            if (stats.isFile() && !cachedHash[filename]) {
+                cachedHash[filename] = this.hash(stats, filename);
+                cachedSize[filename] = stats.size;
+            }
+        }
+    }
+    refresh(filename) {
+        const { cachedHash, cachedSize } = this;
+        if (fs.existsSync(filename)) {
+            const stats = fs.statSync(filename);
+            if (stats.isFile()) {
+                cachedHash[filename] = this.hash(stats, filename);
+                cachedSize[filename] = stats.size;
+            }
+        }
+    }
+    del(filename) {
+        if (this.cachedHash[filename]) {
+            delete this.cachedHash[filename];
+            delete this.cachedSize[filename];
+        }
+    }
+    isDiff(filename) {
+        const { cachedHash, cachedSize } = this;
+        const stats = fs.statSync(filename);
+        const hash = cachedHash[filename];
+        const size = cachedSize[filename];
+        if (stats.size !== size) return true;
+        if (this.hash(stats, filename) !== hash) return true;
+        return false;
+    }
+    has(filename) {
+        return Boolean(this.cachedHash[filename]);
+    }
+    hash(stats, filename) {
+        return crypto_0.createHash('md5').update(fs.readFileSync(filename)).digest('hex');
+    }
+    constructor(){
+        this.cachedHash = {};
+        this.cachedSize = {};
+    }
+}
+export { StatsCache };

package/dist/esm/dev.mjs

@@ -0,0 +1,77 @@
+import { connectMid2HonoMid } from "@modern-js/server-core/node";
+import { API_DIR, SHARED_DIR } from "@modern-js/utils";
+import { getDevOptions, getMockMiddleware, initFileReader, onRepack, startWatcher } from "./helpers/index.mjs";
+const devPlugin = (options, compiler)=>({
+        name: '@modern-js/plugin-dev',
+        setup (api) {
+            const { config, pwd, builder, builderDevServer } = options;
+            const closeCb = [];
+            const dev = getDevOptions(options.dev);
+            api.onPrepare(async ()=>{
+                const { middlewares: builderMiddlewares, close, connectWebSocket } = builderDevServer || {};
+                close && closeCb.push(close);
+                const { middlewares, distDirectory, nodeServer, apiDirectory, sharedDirectory, serverBase } = api.getServerContext();
+                connectWebSocket && nodeServer && connectWebSocket({
+                    server: nodeServer
+                });
+                const hooks = api.getHooks();
+                builder?.onDevCompileDone(({ stats })=>{
+                    if ('server' !== stats.toJson({
+                        all: false
+                    }).name) onRepack(distDirectory, hooks);
+                });
+                const { watchOptions } = config.server;
+                const watcher = startWatcher({
+                    pwd,
+                    distDir: distDirectory,
+                    apiDir: apiDirectory || API_DIR,
+                    sharedDir: sharedDirectory || SHARED_DIR,
+                    watchOptions,
+                    server: serverBase
+                });
+                closeCb.push(watcher.close.bind(watcher));
+                closeCb.length > 0 && nodeServer?.on('close', ()=>{
+                    closeCb.forEach((cb)=>{
+                        cb();
+                    });
+                });
+                const before = [];
+                const after = [];
+                const { setupMiddlewares = [] } = dev;
+                setupMiddlewares.forEach((handler)=>{
+                    handler({
+                        unshift: (...handlers)=>before.unshift(...handlers),
+                        push: (...handlers)=>after.push(...handlers)
+                    }, {
+                        sockWrite: ()=>{}
+                    });
+                });
+                before.forEach((middleware, index)=>{
+                    middlewares.push({
+                        name: `before-dev-server-${index}`,
+                        handler: connectMid2HonoMid(middleware)
+                    });
+                });
+                const mockMiddleware = await getMockMiddleware(pwd);
+                middlewares.push({
+                    name: 'mock-dev',
+                    handler: mockMiddleware
+                });
+                builderMiddlewares && middlewares.push({
+                    name: 'rsbuild-dev',
+                    handler: connectMid2HonoMid(builderMiddlewares)
+                });
+                after.forEach((middleware, index)=>{
+                    middlewares.push({
+                        name: `after-dev-server-${index}`,
+                        handler: connectMid2HonoMid(middleware)
+                    });
+                });
+                middlewares.push({
+                    name: 'init-file-reader',
+                    handler: initFileReader(compiler)
+                });
+            });
+        }
+    });
+export { devPlugin };

package/dist/esm/helpers/devOptions.mjs

@@ -0,0 +1,24 @@
+const getDevOptions = (devOptions)=>{
+    const defaultOptions = {
+        https: false,
+        server: {}
+    };
+    return {
+        ...defaultOptions,
+        ...devOptions
+    };
+};
+const getDevAssetPrefix = (builder)=>new Promise((resolve)=>{
+        if (!builder) return resolve('');
+        builder?.onAfterCreateCompiler((params)=>{
+            let webCompiler;
+            webCompiler = 'compilers' in params.compiler ? params.compiler.compilers.find((c)=>'web' === c.name || 'client' === c.name) : params.compiler;
+            const publicPath = webCompiler?.options?.output?.publicPath;
+            if (publicPath && 'string' == typeof publicPath) {
+                const formatPublicPath = publicPath.replace(/^https?:\/\/[^/]+/, '');
+                return resolve(formatPublicPath);
+            }
+            return resolve('');
+        });
+    });
+export { getDevAssetPrefix, getDevOptions };

package/dist/esm/helpers/fileReader.mjs

@@ -0,0 +1,19 @@
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
+const initFileReader = (compiler)=>{
+    let isInit = false;
+    return async (ctx, next)=>{
+        if (isInit) return next();
+        isInit = true;
+        const { res } = ctx.env.node;
+        if (!compiler) {
+            fileReader.reset();
+            return next();
+        }
+        const resolvedCompiler = 'compilers' in compiler ? compiler.compilers[0] : compiler;
+        const outputFileSystem = resolvedCompiler?.outputFileSystem;
+        if (outputFileSystem) fileReader.reset(outputFileSystem);
+        else fileReader.reset();
+        return next();
+    };
+};
+export { initFileReader };

package/dist/esm/helpers/index.mjs

@@ -0,0 +1,65 @@
+import { AGGRED_DIR } from "@modern-js/server-core";
+import { SERVER_BUNDLE_DIRECTORY, SERVER_DIR, logger } from "@modern-js/utils";
+import path from "path";
+import dev_tools_watcher, { mergeWatchOptions } from "../dev-tools/watcher/index.mjs";
+import { initOrUpdateMockMiddlewares } from "./mock.mjs";
+import { debug } from "./utils.mjs";
+export * from "./devOptions.mjs";
+export * from "./fileReader.mjs";
+export * from "./mock.mjs";
+export * from "./repack.mjs";
+async function onServerChange({ pwd, filepath, event, server }) {
+    const { mock } = AGGRED_DIR;
+    const mockPath = path.normalize(path.join(pwd, mock));
+    const { hooks } = server;
+    if (filepath.startsWith(mockPath)) {
+        await initOrUpdateMockMiddlewares(pwd);
+        logger.info('Finish update the mock handlers');
+    } else try {
+        const fileChangeEvent = {
+            type: 'file-change',
+            payload: [
+                {
+                    filename: filepath,
+                    event
+                }
+            ]
+        };
+        await hooks.onReset.call({
+            event: fileChangeEvent
+        });
+        debug(`Finish reload server, trigger by ${filepath} ${event}`);
+    } catch (e) {
+        logger.error(e);
+    }
+}
+function startWatcher({ pwd, distDir, apiDir, sharedDir, watchOptions, server }) {
+    const { mock } = AGGRED_DIR;
+    const defaultWatched = [
+        `${mock}/**/*`,
+        `${SERVER_DIR}/**/*`,
+        `${apiDir}/**`,
+        `${sharedDir}/**/*`,
+        `${distDir}/${SERVER_BUNDLE_DIRECTORY}/*-server-loaders.js`
+    ];
+    const mergedWatchOptions = mergeWatchOptions(watchOptions);
+    const defaultWatchedPaths = defaultWatched.map((p)=>{
+        const finalPath = path.isAbsolute(p) ? p : path.join(pwd, p);
+        return path.normalize(finalPath);
+    });
+    const watcher = new dev_tools_watcher();
+    watcher.createDepTree();
+    watcher.listen(defaultWatchedPaths, mergedWatchOptions, (filepath, event)=>{
+        if (filepath.includes('-server-loaders.js')) return void delete require.cache[filepath];
+        watcher.updateDepTree();
+        watcher.cleanDepCache(filepath);
+        onServerChange({
+            pwd,
+            filepath,
+            event,
+            server
+        });
+    });
+    return watcher;
+}
+export { startWatcher };

package/dist/esm/helpers/mock.mjs

@@ -0,0 +1,86 @@
+import node_path from "node:path";
+import { AGGRED_DIR } from "@modern-js/server-core";
+import { connectMockMid2HonoMid } from "@modern-js/server-core/node";
+import { fs } from "@modern-js/utils";
+import { match } from "path-to-regexp";
+let mockAPIs = [];
+let mockConfig;
+const parseKey = (key)=>{
+    const _blank = ' ';
+    const splitted = key.split(_blank).filter(Boolean);
+    if (splitted.length > 1) {
+        const [method, pathname] = splitted;
+        return {
+            method: (method ?? 'get').toLowerCase(),
+            path: pathname ?? '/'
+        };
+    }
+    return {
+        method: 'get',
+        path: key
+    };
+};
+const getMockModule = async (pwd)=>{
+    const exts = [
+        '.ts',
+        '.js'
+    ];
+    let mockFilePath = '';
+    for (const ext of exts){
+        const maybeMatch = node_path.join(pwd, `${AGGRED_DIR.mock}/index${ext}`);
+        if (await fs.pathExists(maybeMatch)) {
+            mockFilePath = maybeMatch;
+            break;
+        }
+    }
+    if (!mockFilePath) return;
+    const { default: mockHandlers, config } = await import(mockFilePath);
+    const enable = config?.enable;
+    if (false === enable) return;
+    if (!mockHandlers) throw new Error(`Mock file ${mockFilePath} parsed failed!`);
+    return {
+        mockHandlers,
+        config
+    };
+};
+const getMatched = (request, mockApis)=>{
+    const { path: targetPathname, method: targetMethod } = request;
+    const matched = mockApis.find((mockApi)=>{
+        const { method, path: pathname } = mockApi;
+        if (method.toLowerCase() === targetMethod.toLowerCase()) return match(pathname, {
+            decode: decodeURIComponent
+        })(targetPathname);
+        return false;
+    });
+    return matched;
+};
+async function initOrUpdateMockMiddlewares(pwd) {
+    const mockModule = await getMockModule(pwd);
+    mockConfig = mockModule?.config;
+    mockAPIs = Object.entries(mockModule?.mockHandlers || {}).map(([key, handler])=>{
+        const { method, path } = parseKey(key);
+        return {
+            method,
+            path,
+            handler
+        };
+    });
+}
+async function getMockMiddleware(pwd) {
+    await initOrUpdateMockMiddlewares(pwd);
+    const mockMiddleware = async (c, next)=>{
+        if ('function' == typeof mockConfig?.enable) {
+            const isEnabled = mockConfig.enable(c.env.node.req, c.env.node.res);
+            if (!isEnabled) return next();
+        }
+        const matchedMockAPI = getMatched(c.req, mockAPIs);
+        if (matchedMockAPI) {
+            const { handler } = matchedMockAPI;
+            if ('function' == typeof handler) return await connectMockMid2HonoMid(handler)(c, next);
+            return c.json(handler);
+        }
+        return next();
+    };
+    return mockMiddleware;
+}
+export { getMatched, getMockMiddleware, initOrUpdateMockMiddlewares };

package/dist/esm/helpers/repack.mjs

@@ -0,0 +1,16 @@
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
+const cleanSSRCache = (distDir)=>{
+    Object.keys(require.cache).forEach((key)=>{
+        if (key.startsWith(distDir)) delete require.cache[key];
+    });
+};
+const onRepack = (distDir, hooks)=>{
+    cleanSSRCache(distDir);
+    fileReader.reset();
+    hooks.onReset.call({
+        event: {
+            type: 'repack'
+        }
+    });
+};
+export { onRepack };

package/dist/esm/helpers/utils.mjs

@@ -0,0 +1,3 @@
+import { createDebugger } from "@modern-js/utils";
+const debug = createDebugger('server');
+export { debug };

package/dist/esm/index.mjs

@@ -0,0 +1 @@
+export { createDevServer } from "./createDevServer.mjs";

package/dist/esm-node/createDevServer.mjs

@@ -0,0 +1,59 @@
+import "node:module";
+import node_path from "node:path";
+import { createServerBase } from "@modern-js/server-core";
+import { createNodeServer, loadServerRuntimeConfig } from "@modern-js/server-core/node";
+import { devPlugin } from "./dev.mjs";
+import { getDevAssetPrefix, getDevOptions } from "./helpers/index.mjs";
+async function createDevServer(options, applyPlugins) {
+    const { config, pwd, serverConfigPath, builder } = options;
+    const dev = getDevOptions(options.dev);
+    const distDir = node_path.resolve(pwd, config.output.distPath?.root || 'dist');
+    const serverConfig = await loadServerRuntimeConfig(serverConfigPath) || {};
+    const prodServerOptions = {
+        ...options,
+        pwd: distDir,
+        serverConfig: {
+            ...serverConfig,
+            ...options.serverConfig
+        },
+        plugins: [
+            ...serverConfig.plugins || [],
+            ...options.plugins || []
+        ]
+    };
+    const server = createServerBase(prodServerOptions);
+    const devHttpsOption = 'object' == typeof dev && dev.https;
+    const isHttp2 = !!devHttpsOption;
+    let nodeServer;
+    if (devHttpsOption) {
+        const { genHttpsOptions } = await import("./dev-tools/https/index.mjs");
+        const httpsOptions = await genHttpsOptions(devHttpsOption, pwd);
+        nodeServer = await createNodeServer(server.handle.bind(server), httpsOptions, isHttp2);
+    } else nodeServer = await createNodeServer(server.handle.bind(server));
+    const promise = getDevAssetPrefix(builder);
+    let compiler = null;
+    builder?.onAfterCreateCompiler((context)=>{
+        compiler = context.compiler;
+    });
+    const builderDevServer = await builder?.createDevServer({
+        runCompile: options.runCompile
+    });
+    server.addPlugins([
+        devPlugin({
+            ...options,
+            builderDevServer
+        }, compiler)
+    ]);
+    const assetPrefix = await promise;
+    if (assetPrefix) prodServerOptions.config.output.assetPrefix = assetPrefix;
+    await applyPlugins(server, prodServerOptions, nodeServer);
+    await server.init();
+    const afterListen = async ()=>{
+        await builderDevServer?.afterListen();
+    };
+    return {
+        server: nodeServer,
+        afterListen
+    };
+}
+export { createDevServer };

package/dist/esm-node/dev-tools/https/index.mjs

@@ -0,0 +1,28 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import { chalk, getPackageManager, logger, tryResolve } from "@modern-js/utils";
+import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
+import { dirname as __rspack_dirname } from "node:path";
+var https_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+const genHttpsOptions = async (userOptions, pwd)=>{
+    const httpsOptions = 'boolean' == typeof userOptions ? {} : userOptions;
+    if (!httpsOptions.key || !httpsOptions.cert) {
+        let devcertPath;
+        try {
+            devcertPath = tryResolve('devcert', pwd, https_dirname);
+        } catch (err) {
+            const packageManager = await getPackageManager(pwd);
+            const command = chalk.yellow.bold(`${packageManager} add devcert@1.2.2 -D`);
+            logger.error('You have enabled "dev.https" option, but the "devcert" package is not installed.');
+            logger.error(`Please run ${command} to install manually, otherwise the https can not work.`);
+            throw new Error('[https] "devcert" is not found.');
+        }
+        const devcert = require(devcertPath);
+        const selfsign = await devcert.certificateFor([
+            'localhost'
+        ]);
+        return selfsign;
+    }
+    return httpsOptions;
+};
+export { genHttpsOptions };

package/dist/esm-node/dev-tools/watcher/dependencyTree.mjs

@@ -0,0 +1,58 @@
+import "node:module";
+import * as __rspack_external_minimatch from "minimatch";
+const defaultIgnores = [
+    '**/coverage/**',
+    '**/node_modules/**',
+    '**/.*/**',
+    '**/*.d.ts',
+    '**/*.log'
+];
+class DependencyTree {
+    getNode(path) {
+        return this.tree.get(path);
+    }
+    update(cache) {
+        this.tree.clear();
+        Object.keys(cache).forEach((path)=>{
+            if (!this.shouldIgnore(path)) {
+                const module = cache[path];
+                this.tree.set(module.filename, {
+                    module,
+                    parent: new Set(),
+                    children: new Set()
+                });
+            }
+        });
+        for (const treeNode of this.tree.values()){
+            const { parent } = treeNode.module;
+            const { children } = treeNode.module;
+            if (parent && !this.shouldIgnore(parent.filename)) {
+                const parentTreeNode = this.tree.get(parent.filename);
+                if (parentTreeNode) treeNode.parent.add(parentTreeNode);
+            }
+            children?.forEach((child)=>{
+                if (!this.shouldIgnore(child.filename)) {
+                    const childTreeNode = this.tree.get(child.filename);
+                    if (childTreeNode) {
+                        treeNode.children.add(childTreeNode);
+                        childTreeNode.parent.add(treeNode);
+                    }
+                }
+            });
+        }
+    }
+    shouldIgnore(path) {
+        return !path || Boolean(this.ignore.find((rule)=>__rspack_external_minimatch.match([
+                path
+            ], rule, {
+                dot: true
+            }).length > 0));
+    }
+    constructor(){
+        this.tree = new Map();
+        this.ignore = [
+            ...defaultIgnores
+        ];
+    }
+}
+export { DependencyTree, defaultIgnores };