@shuvi/platform-web 0.0.1-rc.34 → 1.0.0-rc.2

package/lib/node/features/filesystem-routes/api/apiRouteHandler.js

@@ -0,0 +1,237 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiError = exports.sendJson = exports.sendData = exports.redirect = exports.sendStatusCode = exports.getCookieParser = exports.parseBody = exports.apiRouteHandler = void 0;
+const stream_1 = require("stream");
+const querystring = __importStar(require("querystring"));
+const cookie = __importStar(require("cookie"));
+const getRawBody = require('raw-body');
+const contentType = __importStar(require("content-type"));
+function apiRouteHandler(req, res, resolver, apiRoutesConfig) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const { bodyParser } = apiRoutesConfig || {};
+            const { pathname, query, params } = req;
+            const apiReq = {
+                pathname,
+                query,
+                params,
+                // Parsing of cookies
+                cookies: getCookieParser(req)
+            };
+            // Parsing of body
+            if (bodyParser && !apiReq.body) {
+                apiReq.body = yield parseBody(req, bodyParser && bodyParser.sizeLimit ? bodyParser.sizeLimit : '1mb');
+            }
+            const apiRes = {
+                status: (statusCode) => sendStatusCode(res, statusCode),
+                send: (data) => sendData(req, res, data),
+                json: (data) => sendJson(req, res, data),
+                redirect: (statusOrUrl, url) => redirect(res, statusOrUrl, url)
+            };
+            let wasPiped = false;
+            if (process.env.NODE_ENV !== 'production') {
+                // listen for pipe event and don't show resolve warning
+                res.once('pipe', () => (wasPiped = true));
+            }
+            // Call API route method
+            yield resolver(Object.assign(req, apiReq), Object.assign(res, apiRes));
+            if (process.env.NODE_ENV !== 'production' &&
+                !(res.finished || res.headersSent) &&
+                !wasPiped) {
+                console.warn(`API resolved without sending a response for ${req.url}, this may result in stalled requests.`);
+            }
+        }
+        catch (err) {
+            throw err;
+        }
+    });
+}
+exports.apiRouteHandler = apiRouteHandler;
+/**
+ * Parse incoming message like `json` or `urlencoded`
+ * @param req request object
+ */
+function parseBody(req, limit) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let contentTypeObj;
+        try {
+            contentTypeObj = contentType.parse(req.headers['content-type'] || 'text/plain');
+        }
+        catch (_a) {
+            contentTypeObj = contentType.parse('text/plain');
+        }
+        const { type, parameters } = contentTypeObj;
+        const encoding = (parameters.charset && parameters.charset.toLowerCase()) || 'utf-8';
+        let buffer;
+        try {
+            buffer = yield getRawBody(req, { encoding, limit });
+        }
+        catch (e) {
+            if (e.type === 'entity.too.large') {
+                throw new ApiError(413, `Body exceeded ${limit} limit`);
+            }
+            else {
+                throw new ApiError(400, 'Invalid body');
+            }
+        }
+        const body = buffer.toString();
+        if (type === 'application/json' || type === 'application/ld+json') {
+            return parseJson(body);
+        }
+        else if (type === 'application/x-www-form-urlencoded') {
+            return querystring.decode(body);
+        }
+        else {
+            return body;
+        }
+    });
+}
+exports.parseBody = parseBody;
+/**
+ * Parse `JSON` and handles invalid `JSON` strings
+ * @param str `JSON` string
+ */
+function parseJson(str) {
+    if (str.length === 0) {
+        // special-case empty json body, as it's a common client-side mistake
+        return {};
+    }
+    try {
+        return JSON.parse(str);
+    }
+    catch (e) {
+        throw new ApiError(400, 'Invalid JSON');
+    }
+}
+/**
+ * Parse cookies from `req` header
+ * @param req request object
+ */
+function getCookieParser(req) {
+    const header = req.headers.cookie;
+    if (!header) {
+        return {};
+    }
+    return cookie.parse(Array.isArray(header) ? header.join(';') : header);
+}
+exports.getCookieParser = getCookieParser;
+/**
+ *
+ * @param res ServerResponse object
+ * @param statusCode `HTTP` status code of response
+ */
+function sendStatusCode(res, statusCode) {
+    res.statusCode = statusCode;
+    return res;
+}
+exports.sendStatusCode = sendStatusCode;
+/**
+ *
+ * @param res response object
+ * @param [statusOrUrl] `HTTP` status code of redirect
+ * @param url URL of redirect
+ */
+function redirect(res, statusOrUrl, url) {
+    if (typeof statusOrUrl === 'string') {
+        url = statusOrUrl;
+        statusOrUrl = 307;
+    }
+    if (typeof statusOrUrl !== 'number' || typeof url !== 'string') {
+        throw new Error(`Invalid redirect arguments. Please use a single argument URL, e.g. res.redirect('/destination') or use a status code and URL, e.g. res.redirect(307, '/destination').`);
+    }
+    res.writeHead(statusOrUrl, { Location: url });
+    res.write('');
+    res.end();
+    return res;
+}
+exports.redirect = redirect;
+/**
+ * Send `any` body to response
+ * @param req request object
+ * @param res response object
+ * @param body of response
+ */
+function sendData(req, res, body) {
+    if (body === null || body === undefined) {
+        res.end();
+        return;
+    }
+    const contentType = res.getHeader('Content-Type');
+    if (body instanceof stream_1.Stream) {
+        if (!contentType) {
+            res.setHeader('Content-Type', 'application/octet-stream');
+        }
+        body.pipe(res);
+        return;
+    }
+    const isJSONLike = ['object', 'number', 'boolean'].includes(typeof body);
+    const stringifiedBody = isJSONLike ? JSON.stringify(body) : body;
+    if (Buffer.isBuffer(body)) {
+        if (!contentType) {
+            res.setHeader('Content-Type', 'application/octet-stream');
+        }
+        res.setHeader('Content-Length', body.length);
+        res.end(body);
+        return;
+    }
+    if (isJSONLike) {
+        res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    }
+    res.setHeader('Content-Length', Buffer.byteLength(stringifiedBody));
+    res.end(stringifiedBody);
+}
+exports.sendData = sendData;
+/**
+ * Send `JSON` object
+ * @param res response object
+ * @param jsonBody of data
+ */
+function sendJson(req, res, jsonBody) {
+    // Set header to application/json
+    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    // Use send to handle request
+    return sendData(req, res, jsonBody);
+}
+exports.sendJson = sendJson;
+/**
+ * Custom error class
+ */
+class ApiError extends Error {
+    constructor(statusCode, message) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+exports.ApiError = ApiError;

package/lib/node/features/filesystem-routes/api/apiRoutes.d.ts

@@ -0,0 +1,7 @@
+import { IApiRouteConfig } from '@shuvi/platform-shared/node';
+export { IApiRouteConfig };
+export declare function serializeApiRoutes(apiRoutes: IApiRouteConfig[]): string;
+export declare function normalizeApiRoutes(apiRoutes: IApiRouteConfig[], option: {
+    apisDir: string;
+}): IApiRouteConfig[];
+export declare const generateRoutesContent: (apiRoutes: IApiRouteConfig[], apisDir: string) => string;

package/lib/node/features/filesystem-routes/api/apiRoutes.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRoutesContent = exports.normalizeApiRoutes = exports.serializeApiRoutes = void 0;
+const file_1 = require("@shuvi/utils/lib/file");
+function serializeApiRoutes(apiRoutes) {
+    let res = '';
+    for (let index = 0; index < apiRoutes.length; index++) {
+        const { api, path } = apiRoutes[index];
+        let strRoute = `\n{
+      path: "${path}",
+      ${api ? `api: require("${api}"),` : ''}
+    },`;
+        res += strRoute;
+    }
+    return `[${res}]`;
+}
+exports.serializeApiRoutes = serializeApiRoutes;
+function normalizeApiRoutes(apiRoutes, option) {
+    const res = [];
+    for (let index = 0; index < apiRoutes.length; index++) {
+        const apiRoute = Object.assign({}, apiRoutes[index]);
+        if (apiRoute.api) {
+            apiRoute.api = (0, file_1.normalizePath)(apiRoute.api, option.apisDir);
+        }
+        res.push(apiRoute);
+    }
+    return res;
+}
+exports.normalizeApiRoutes = normalizeApiRoutes;
+const generateRoutesContent = (apiRoutes, apisDir) => {
+    const normalizedRoutes = normalizeApiRoutes(apiRoutes, { apisDir });
+    const serialized = serializeApiRoutes(normalizedRoutes);
+    return `export default ${serialized}`;
+};
+exports.generateRoutesContent = generateRoutesContent;

package/lib/node/features/filesystem-routes/api/index.d.ts

@@ -0,0 +1,3 @@
+export { middleware } from './middleware';
+export { generateRoutesContent, IApiRouteConfig } from './apiRoutes';
+export { IApiRequestHandler } from './apiRouteHandler';

package/lib/node/features/filesystem-routes/api/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRoutesContent = exports.middleware = void 0;
+var middleware_1 = require("./middleware");
+Object.defineProperty(exports, "middleware", { enumerable: true, get: function () { return middleware_1.middleware; } });
+var apiRoutes_1 = require("./apiRoutes");
+Object.defineProperty(exports, "generateRoutesContent", { enumerable: true, get: function () { return apiRoutes_1.generateRoutesContent; } });

package/lib/node/features/filesystem-routes/api/middleware.d.ts

@@ -0,0 +1,2 @@
+import { IServerPluginContext, IRequestHandlerWithNext } from '@shuvi/service';
+export declare function middleware(_ctx: IServerPluginContext): IRequestHandlerWithNext;

package/lib/node/features/filesystem-routes/api/middleware.js

@@ -0,0 +1,44 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.middleware = void 0;
+const router_1 = require("@shuvi/router");
+const resources_1 = require("@shuvi/service/lib/resources");
+const apiRouteHandler_1 = require("./apiRouteHandler");
+function middleware(_ctx) {
+    return function (req, res, next) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { apiRoutes } = resources_1.server;
+            let tempApiModule;
+            for (const { path, api } of apiRoutes) {
+                const match = (0, router_1.matchPathname)(path, req.pathname);
+                if (match) {
+                    req.params = match.params;
+                    tempApiModule = api;
+                    break;
+                }
+            }
+            if (tempApiModule) {
+                try {
+                    const { config, default: resolver } = tempApiModule;
+                    yield (0, apiRouteHandler_1.apiRouteHandler)(req, res, resolver, (config === null || config === void 0 ? void 0 : config.api) || { bodyParser: true });
+                }
+                catch (error) {
+                    next(error);
+                }
+            }
+            else {
+                next();
+            }
+        });
+    };
+}
+exports.middleware = middleware;

package/lib/node/features/filesystem-routes/hooks.d.ts

@@ -0,0 +1,3 @@
+import { IPageRouteConfig, IMiddlewareRouteConfig } from '@shuvi/platform-shared/shared';
+export declare const addRoutes: import("@shuvi/hook").AsyncParallelHook<void, void, IPageRouteConfig[]>;
+export declare const addMiddlewareRoutes: import("@shuvi/hook").AsyncParallelHook<void, void, IMiddlewareRouteConfig[]>;

package/lib/node/features/filesystem-routes/hooks.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addMiddlewareRoutes = exports.addRoutes = void 0;
+const hook_1 = require("@shuvi/hook");
+exports.addRoutes = (0, hook_1.createAsyncParallelHook)();
+exports.addMiddlewareRoutes = (0, hook_1.createAsyncParallelHook)();

package/lib/node/features/filesystem-routes/index.d.ts

@@ -0,0 +1,20 @@
+import { getRoutes } from './page';
+import { middleware as getMiddlewareMiddleware } from './middleware';
+import { IApiRequestHandler, middleware as getApiMiddleware } from './api';
+export { IApiRequestHandler, getRoutes, getMiddlewareMiddleware, getApiMiddleware };
+declare const _default: {
+    core: import("@shuvi/platform-shared/shared").IPluginInstance<{
+        extendConfig: import("@shuvi/hook").SyncWaterfallHook<import("@shuvi/service").Config, void>;
+        afterInit: import("@shuvi/hook").AsyncParallelHook<void, void, void>;
+        afterBuild: import("@shuvi/hook").AsyncParallelHook<void, void, void>;
+        afterDestroy: import("@shuvi/hook").AsyncParallelHook<void, void, void>;
+        afterBundlerDone: import("@shuvi/hook").AsyncParallelHook<import("@shuvi/service/lib/core/lifecycleTypes").BundlerDoneExtra, void, void>;
+        afterBundlerTargetDone: import("@shuvi/hook").AsyncParallelHook<import("@shuvi/service/lib/core/lifecycleTypes").BundlerTargetDoneExtra, void, void>;
+        configWebpack: import("@shuvi/hook").AsyncSeriesWaterfallHook<import("@shuvi/service/lib/core/lifecycleTypes").WebpackChainType, import("@shuvi/service/lib/core/lifecycleTypes").ConfigWebpackAssistant>;
+        addExtraTarget: import("@shuvi/hook").AsyncParallelHook<import("@shuvi/service/lib/core/lifecycleTypes").ExtraTargetAssistant, void, import("@shuvi/service/lib/core/lifecycleTypes").TargetChain>;
+        addResource: import("@shuvi/hook").AsyncParallelHook<void, void, import("@shuvi/service/lib/core/lifecycleTypes").Resources | import("@shuvi/service/lib/core/lifecycleTypes").Resources[]>;
+        addRuntimeFile: import("@shuvi/hook").AsyncParallelHook<void, import("@shuvi/service/lib/core/lifecycleTypes").AddRuntimeFileUtils, import("@shuvi/service/lib/project/index").FileOptions<any, any> | import("@shuvi/service/lib/project/index").FileOptions<any, any>[]>;
+        addRuntimeService: import("@shuvi/hook").AsyncParallelHook<void, void, import("@shuvi/service/lib/core/lifecycleTypes").RuntimeService | import("@shuvi/service/lib/core/lifecycleTypes").RuntimeService[]>;
+    } & import("@shuvi/service/lib/core/apiTypes").CustomCorePluginHooks, import("@shuvi/service").IPluginContext>;
+};
+export default _default;

package/lib/node/features/filesystem-routes/index.js

@@ -0,0 +1,180 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getApiMiddleware = exports.getMiddlewareMiddleware = exports.getRoutes = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const build_loaders_1 = require("@shuvi/toolpack/lib/utils/build-loaders");
+const service_1 = require("@shuvi/service");
+const node_1 = require("@shuvi/platform-shared/node");
+const lib_1 = require("../html-render/lib");
+const hooks_1 = require("./hooks");
+const page_1 = require("./page");
+Object.defineProperty(exports, "getRoutes", { enumerable: true, get: function () { return page_1.getRoutes; } });
+const middleware_1 = require("./middleware");
+Object.defineProperty(exports, "getMiddlewareMiddleware", { enumerable: true, get: function () { return middleware_1.middleware; } });
+const api_1 = require("./api");
+Object.defineProperty(exports, "getApiMiddleware", { enumerable: true, get: function () { return api_1.middleware; } });
+const plugin = (0, service_1.createPlugin)({
+    setup: ({ addHooks }) => {
+        addHooks({ addRoutes: hooks_1.addRoutes, addMiddlewareRoutes: hooks_1.addMiddlewareRoutes });
+    },
+    addRuntimeFile: ({ defineFile }, context) => __awaiter(void 0, void 0, void 0, function* () {
+        const { config: { routes: pageRoutes, middlewareRoutes, apiRoutes, conventionRoutes }, paths, pluginRunner, phase } = context;
+        const isBuildPhase = phase === 'PHASE_PRODUCTION_BUILD';
+        const pageRoutesFile = defineFile({
+            name: 'routes.js',
+            content: () => __awaiter(void 0, void 0, void 0, function* () {
+                let routes;
+                const hasConfigRoutes = Array.isArray(pageRoutes);
+                if (hasConfigRoutes) {
+                    routes = pageRoutes;
+                }
+                else {
+                    const { routes: _routes, warnings } = yield (0, node_1.getPageRoutes)(paths.routesDir, conventionRoutes.exclude);
+                    if (isBuildPhase) {
+                        warnings.forEach(warning => {
+                            console.warn(warning.msg);
+                        });
+                    }
+                    routes = _routes;
+                }
+                const extraRoutes = (yield pluginRunner.addRoutes()).flat();
+                const normalizedRoutes = (0, page_1.normalizeRoutes)(
+                // user routes come later
+                extraRoutes.concat(routes), paths.routesDir);
+                (0, page_1.setRoutes)(normalizedRoutes);
+                return (0, page_1.generateRoutesContent)(normalizedRoutes);
+            }),
+            dependencies: [paths.routesDir]
+        });
+        const apiRoutesFile = defineFile({
+            name: 'apiRoutes.js',
+            content: () => __awaiter(void 0, void 0, void 0, function* () {
+                let routes;
+                const hasConfigRoutes = Array.isArray(apiRoutes);
+                if (hasConfigRoutes) {
+                    routes = apiRoutes;
+                }
+                else {
+                    const { routes: _routes, warnings } = yield (0, node_1.getApiRoutes)(paths.routesDir, conventionRoutes.exclude);
+                    if (isBuildPhase) {
+                        warnings.forEach(warning => {
+                            console.warn(warning);
+                        });
+                    }
+                    routes = _routes;
+                }
+                return (0, api_1.generateRoutesContent)(routes, paths.routesDir);
+            }),
+            dependencies: [paths.routesDir]
+        });
+        const middlewareRoutesFile = defineFile({
+            name: 'middlewareRoutes.js',
+            content: () => __awaiter(void 0, void 0, void 0, function* () {
+                let routes;
+                const hasConfigRoutes = Array.isArray(middlewareRoutes);
+                if (hasConfigRoutes) {
+                    routes = middlewareRoutes;
+                }
+                else {
+                    const { routes: _routes, warnings } = yield (0, node_1.getMiddlewareRoutes)(paths.routesDir, conventionRoutes.exclude);
+                    if (isBuildPhase) {
+                        warnings.forEach(warning => {
+                            console.warn(warning);
+                        });
+                    }
+                    routes = _routes;
+                }
+                const extraRoutes = (yield pluginRunner.addMiddlewareRoutes()).flat();
+                return (0, middleware_1.generateRoutesContent)(extraRoutes.concat(routes), {
+                    baseDir: paths.routesDir
+                });
+            }),
+            dependencies: [paths.routesDir]
+        });
+        const loadersFile = defineFile({
+            name: 'loaders.js',
+            content: () => __awaiter(void 0, void 0, void 0, function* () {
+                const routes = (0, page_1.getRoutes)();
+                const loaders = {};
+                const traverseRoutes = (routes) => {
+                    routes.forEach(r => {
+                        const { component, id, children } = r;
+                        if (component && id) {
+                            const hasLoader = (0, lib_1.ifComponentHasLoader)(component);
+                            if (hasLoader) {
+                                loaders[id] = component;
+                            }
+                        }
+                        if (children) {
+                            traverseRoutes(children);
+                        }
+                    });
+                };
+                traverseRoutes(routes);
+                let imports = '';
+                let exports = '';
+                Object.entries(loaders).forEach((loader, index) => {
+                    const [id, component] = loader;
+                    imports += `import { loader as loader_${index} } from '${component}'\n`;
+                    exports += `'${id}': loader_${index},\n`;
+                });
+                return `${imports}  export default {\n  ${exports}\n}`;
+            }),
+            dependencies: [pageRoutesFile]
+        });
+        const loadersFileName = path.join(context.paths.appDir, 'files', 'loaders.js');
+        const pageLoadersFile = defineFile({
+            name: 'page-loaders.js',
+            content: () => __awaiter(void 0, void 0, void 0, function* () {
+                if (fs.existsSync(loadersFileName)) {
+                    return yield (0, build_loaders_1.buildToString)(loadersFileName);
+                }
+                return '';
+            }),
+            dependencies: [loadersFile]
+        });
+        return [
+            pageRoutesFile,
+            apiRoutesFile,
+            middlewareRoutesFile,
+            loadersFile,
+            pageLoadersFile
+        ];
+    })
+});
+exports.default = {
+    core: plugin
+};

package/lib/node/features/filesystem-routes/middleware/index.d.ts

@@ -0,0 +1,2 @@
+export { middleware } from './middleware';
+export { generateRoutesContent, IMiddlewareRouteConfig } from './routes';

package/lib/node/features/filesystem-routes/middleware/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRoutesContent = exports.middleware = void 0;
+var middleware_1 = require("./middleware");
+Object.defineProperty(exports, "middleware", { enumerable: true, get: function () { return middleware_1.middleware; } });
+var routes_1 = require("./routes");
+Object.defineProperty(exports, "generateRoutesContent", { enumerable: true, get: function () { return routes_1.generateRoutesContent; } });

package/lib/node/features/filesystem-routes/middleware/middleware.d.ts

@@ -0,0 +1,2 @@
+import { IServerPluginContext, IRequestHandlerWithNext } from '@shuvi/service';
+export declare function middleware(_api: IServerPluginContext): IRequestHandlerWithNext;

package/lib/node/features/filesystem-routes/middleware/middleware.js

@@ -0,0 +1,42 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.middleware = void 0;
+const router_1 = require("@shuvi/router");
+const resources_1 = require("@shuvi/service/lib/resources");
+function middleware(_api) {
+    return function (req, res, next) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { middlewareRoutes = [] } = resources_1.server;
+            // match path for get middlewares
+            let middlewares = [];
+            for (let i = 0; i < middlewareRoutes.length; i++) {
+                const middlewareRoute = middlewareRoutes[i];
+                const match = (0, router_1.matchPathname)(middlewareRoute.path, req.pathname);
+                if (match) {
+                    req.params = match.params;
+                    middlewares.push(middlewareRoutes[i].middleware.default);
+                }
+            }
+            // run middlewares
+            let i = 0;
+            const runNext = () => runMiddleware(middlewares[++i]);
+            const runMiddleware = (middleware) => __awaiter(this, void 0, void 0, function* () {
+                if (i === middlewares.length) {
+                    return next();
+                }
+                yield middleware(req, res, runNext);
+            });
+            return yield runMiddleware(middlewares[i]);
+        });
+    };
+}
+exports.middleware = middleware;

package/lib/node/features/filesystem-routes/middleware/routes.d.ts

@@ -0,0 +1,9 @@
+import { IMiddlewareRouteConfig } from '@shuvi/platform-shared/node';
+export { IMiddlewareRouteConfig };
+export declare function normalizeMiddlewareRoutes(middlewareRoutes: IMiddlewareRouteConfig[], option: {
+    baseDir: string;
+}): IMiddlewareRouteConfig[];
+export declare function serializeMiddlewareRoutes(middlewareRoutes: IMiddlewareRouteConfig[]): string;
+export declare function generateRoutesContent(rawRoutes: IMiddlewareRouteConfig[], { baseDir }: {
+    baseDir: string;
+}): string;

package/lib/node/features/filesystem-routes/middleware/routes.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRoutesContent = exports.serializeMiddlewareRoutes = exports.normalizeMiddlewareRoutes = void 0;
+const file_1 = require("@shuvi/utils/lib/file");
+function normalizeMiddlewareRoutes(middlewareRoutes, option) {
+    const res = [];
+    for (let index = 0; index < middlewareRoutes.length; index++) {
+        const middlewareRoute = Object.assign({}, middlewareRoutes[index]);
+        if (middlewareRoute.middleware) {
+            middlewareRoute.middleware = (0, file_1.normalizePath)(middlewareRoute.middleware, option.baseDir);
+        }
+        res.push(middlewareRoute);
+    }
+    return res;
+}
+exports.normalizeMiddlewareRoutes = normalizeMiddlewareRoutes;
+function serializeMiddlewareRoutes(middlewareRoutes) {
+    let res = '';
+    for (let index = 0; index < middlewareRoutes.length; index++) {
+        const { middleware, path } = middlewareRoutes[index];
+        let strRoute = `\n{
+      path: "${path}",
+      ${middleware ? `middleware: require("${middleware}"),` : ''}
+    },`;
+        res += strRoute;
+    }
+    return `[${res}]`;
+}
+exports.serializeMiddlewareRoutes = serializeMiddlewareRoutes;
+function generateRoutesContent(rawRoutes, { baseDir }) {
+    const serialized = serializeMiddlewareRoutes(normalizeMiddlewareRoutes(rawRoutes, { baseDir }));
+    return `export default ${serialized}`;
+}
+exports.generateRoutesContent = generateRoutesContent;