@modern-js/server 2.69.5 → 3.0.0-alpha.0

package/dist/cjs/helpers/utils.js

@@ -1,29 +1,37 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var utils_exports = {};
-__export(utils_exports, {
-  debug: () => debug
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    debug: ()=>debug
 });
-module.exports = __toCommonJS(utils_exports);
-var import_utils = require("@modern-js/utils");
-const debug = (0, import_utils.createDebugger)("server");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  debug
+const utils_namespaceObject = require("@modern-js/utils");
+const debug = (0, utils_namespaceObject.createDebugger)('server');
+exports.debug = __webpack_exports__.debug;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "debug"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/cjs/index.js

@@ -1,28 +1,36 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var src_exports = {};
-__export(src_exports, {
-  createDevServer: () => import_createDevServer.createDevServer
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createDevServer: ()=>external_createDevServer_js_namespaceObject.createDevServer
 });
-module.exports = __toCommonJS(src_exports);
-var import_createDevServer = require("./createDevServer");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createDevServer
+const external_createDevServer_js_namespaceObject = require("./createDevServer.js");
+exports.createDevServer = __webpack_exports__.createDevServer;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createDevServer"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/cjs/types.js

@@ -1,16 +1,18 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var types_exports = {};
-module.exports = __toCommonJS(types_exports);
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/createDevServer.mjs

@@ -0,0 +1,59 @@
+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";
+import { getDevAssetPrefix, getDevOptions } from "./helpers";
+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");
+        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,
+        compiler: options.compiler
+    });
+    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/dev-tools/https/index.mjs

@@ -0,0 +1,28 @@
+import { chalk, getPackageManager, logger } from "@modern-js/utils";
+const genHttpsOptions = async (userOptions, pwd)=>{
+    const httpsOptions = 'boolean' == typeof userOptions ? {} : userOptions;
+    if (!httpsOptions.key || !httpsOptions.cert) {
+        let devcertPath;
+        try {
+            devcertPath = require.resolve('devcert', {
+                paths: [
+                    pwd,
+                    __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/dev-tools/watcher/dependencyTree.mjs

@@ -0,0 +1,57 @@
+import 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)=>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,88 @@
+import path from "path";
+import { chokidar, fs } from "@modern-js/utils";
+import { DependencyTree } from "./dependencyTree";
+import { StatsCache } from "./statsCache";
+const defaultWatchOptions = {
+    ignoreInitial: true,
+    ignored: /api\/typings\/.*/
+};
+const getWatchedFiles = (watcher)=>{
+    const watched = watcher.getWatched();
+    const files = [];
+    Object.keys(watched).forEach((dir)=>{
+        watched[dir].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 { Watcher as default, 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";
+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,18 @@
+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 { outputFileSystem } = 'compilers' in compiler ? compiler.compilers[0] : compiler;
+        if (outputFileSystem) fileReader.reset(outputFileSystem);
+        else fileReader.reset();
+        return next();
+    };
+};
+export { initFileReader };

package/dist/esm/helpers/index.mjs

@@ -0,0 +1,65 @@
+import path from "path";
+import { AGGRED_DIR } from "@modern-js/server-core";
+import { SERVER_BUNDLE_DIRECTORY, SERVER_DIR, logger } from "@modern-js/utils";
+import dev_tools_watcher, { mergeWatchOptions } from "../dev-tools/watcher";
+import { initOrUpdateMockMiddlewares } from "./mock";
+import { debug } from "./utils";
+export * from "./repack";
+export * from "./devOptions";
+export * from "./fileReader";
+export * from "./mock";
+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 };