@shuvi/platform-web 1.0.0-rc.3 → 1.0.0-rc.6

package/esm/shuvi-app/dev/index.js

@@ -0,0 +1,27 @@
+import { DEV_SOCKET_TIMEOUT_MS, DEV_HOT_MIDDLEWARE_PATH, DEV_HOT_LAUNCH_EDITOR_ENDPOINT } from '@shuvi/shared/esm/constants';
+import connect from './hotDevClient';
+let devClient;
+export const initHMRAndDevClient = (app) => {
+    if (devClient) {
+        return devClient;
+    }
+    devClient = connect({
+        launchEditorEndpoint: DEV_HOT_LAUNCH_EDITOR_ENDPOINT,
+        path: DEV_HOT_MIDDLEWARE_PATH,
+        location
+    });
+    setInterval(() => {
+        devClient.sendMessage(JSON.stringify({
+            event: 'updatePageStatus',
+            currentRoutes: app.router.current.matches.map(({ route: { __componentRawRequest__ } }) => __componentRawRequest__),
+            page: location.pathname
+        }));
+    }, DEV_SOCKET_TIMEOUT_MS / 2);
+    devClient.subscribeToHmrEvent((event) => {
+        // if (obj.action === "reloadPage") {
+        //   return window.location.reload();
+        // }
+        // throw new Error("Unexpected action " + obj.action);
+    });
+    return devClient;
+};

package/esm/shuvi-app/dev/websocket.d.ts

@@ -0,0 +1,16 @@
+export declare function addMessageListener(cb: (event: any) => void): void;
+export declare function sendMessage(data: any): any;
+export declare type HotDevClient = {
+    sendMessage: (data: any) => void;
+    subscribeToHmrEvent?: (handler: any) => void;
+};
+export declare function connectHMR(options: {
+    path: string;
+    timeout: number;
+    log?: boolean;
+    location: {
+        protocol: string;
+        hostname: string;
+        port?: string;
+    };
+}): void;

package/esm/shuvi-app/dev/websocket.js

@@ -0,0 +1,61 @@
+let source;
+const eventCallbacks = [];
+let lastActivity = Date.now();
+let initDataBeforeWsOnline = [];
+function getSocketProtocol(protocol) {
+    return protocol === 'http:' ? 'ws' : 'wss';
+}
+export function addMessageListener(cb) {
+    eventCallbacks.push(cb);
+}
+export function sendMessage(data) {
+    if (!source || source.readyState !== source.OPEN) {
+        initDataBeforeWsOnline.push(data);
+        return;
+    }
+    return source.send(data);
+}
+export function connectHMR(options) {
+    if (!options.timeout) {
+        options.timeout = 5000;
+    }
+    init();
+    let timer = setInterval(function () {
+        if (Date.now() - lastActivity > options.timeout) {
+            handleDisconnect();
+        }
+    }, options.timeout / 2);
+    function init() {
+        if (source)
+            source.close();
+        let { protocol, hostname, port } = options.location;
+        protocol = getSocketProtocol(protocol);
+        let url = `${protocol}://${hostname}:${port}`;
+        source = new WebSocket(`${url}${options.path}`);
+        source.onopen = handleOnline;
+        source.onerror = handleDisconnect;
+        source.onmessage = handleMessage;
+    }
+    function handleOnline() {
+        if (initDataBeforeWsOnline.length !== 0) {
+            initDataBeforeWsOnline.forEach(data => {
+                sendMessage(data);
+            });
+            initDataBeforeWsOnline = [];
+        }
+        if (options.log)
+            console.log('[HMR] connected');
+        lastActivity = Date.now();
+    }
+    function handleMessage(event) {
+        lastActivity = Date.now();
+        eventCallbacks.forEach(cb => {
+            cb(event);
+        });
+    }
+    function handleDisconnect() {
+        clearInterval(timer);
+        source.close();
+        setTimeout(init, options.timeout);
+    }
+}

package/esm/shuvi-app/entry/client/app.d.ts

@@ -1,2 +1,3 @@
+declare const app: import("../../app/client").Application;
 declare const run: () => Promise<void>;
-export { run };
+export { run, app };

package/esm/shuvi-app/entry/client/app.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { CLIENT_CONTAINER_ID } from '@shuvi/shared/lib/constants';
 // renderer must be imported before application
-// we need to init init renderer before import AppComponent
+// we need to init renderer before import AppComponent
 import { view, getRoutes, app as PlatformAppComponent } from '@shuvi/app/core/platform';
 import routes from '@shuvi/app/files/routes';
 import { getAppData } from '@shuvi/platform-shared/shared/helper/getAppData';
@@ -32,7 +32,7 @@ const run = () => __awaiter(void 0, void 0, void 0, function* () {
     yield app.init();
     render();
 });
-export { run };
+export { run, app };
 if (module.hot) {
     const handleHotUpdate = () => __awaiter(void 0, void 0, void 0, function* () {
         const rerender = () => __awaiter(void 0, void 0, void 0, function* () {

package/esm/shuvi-app/entry/client/run.dev.js

@@ -9,11 +9,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 /// <reference lib="dom" />
 import { DEV_STYLE_HIDE_FOUC, DEV_STYLE_PREPARE } from '@shuvi/shared/lib/constants';
-import initWebpackHMR from '../../dev/webpackHotDevClient';
-import { run } from './app';
+import { initHMRAndDevClient } from '../../dev';
+import { run, app } from './app';
 function init() {
     return __awaiter(this, void 0, void 0, function* () {
-        initWebpackHMR();
+        initHMRAndDevClient(app);
         // reduce FOUC caused by style-loader
         const styleReady = new Promise(resolve => {
             (window.requestAnimationFrame || setTimeout)(() => __awaiter(this, void 0, void 0, function* () {
@@ -27,4 +27,4 @@ function init() {
         yield styleReady;
     });
 }
-init().then(run);
+init().then(() => run());

package/esm/shuvi-app/entry/server/index.d.ts

@@ -1,6 +1,7 @@
-import * as application from '../../app/server';
-import * as server from '@shuvi/app/user/server';
+import { default as pageRoutes } from '@shuvi/app/files/routes';
 import { default as apiRoutes } from '@shuvi/app/files/apiRoutes';
 import { default as middlewareRoutes } from '@shuvi/app/files/middlewareRoutes';
-export { server, application, apiRoutes, middlewareRoutes };
-export { view } from '@shuvi/app/core/platform';
+import { view } from '@shuvi/app/core/platform';
+import * as server from '@shuvi/app/user/server';
+import * as application from '../../app/server';
+export { pageRoutes, apiRoutes, middlewareRoutes, server, view, application };

package/esm/shuvi-app/entry/server/index.js

@@ -1,7 +1,8 @@
 // This is the shuvi server-side main module exports collection
-import * as application from '../../app/server';
-import * as server from '@shuvi/app/user/server';
+import { default as pageRoutes } from '@shuvi/app/files/routes';
 import { default as apiRoutes } from '@shuvi/app/files/apiRoutes';
 import { default as middlewareRoutes } from '@shuvi/app/files/middlewareRoutes';
-export { server, application, apiRoutes, middlewareRoutes };
-export { view } from '@shuvi/app/core/platform';
+import { view } from '@shuvi/app/core/platform';
+import * as server from '@shuvi/app/user/server';
+import * as application from '../../app/server';
+export { pageRoutes, apiRoutes, middlewareRoutes, server, view, application };

package/esm/shuvi-app/helper/serializeServerError.d.ts

@@ -0,0 +1,2 @@
+import { IError } from '@shuvi/platform-shared/shared';
+export declare function serializeServerError(err: Error, dev: boolean | undefined): IError;

package/esm/shuvi-app/helper/serializeServerError.js

@@ -0,0 +1,21 @@
+// @ts-ignore
+import stripAnsi from 'strip-ansi';
+function errorToJSON(err) {
+    return {
+        code: 500,
+        message: stripAnsi(err.message),
+        name: err.name,
+        source: 'server',
+        stack: err.stack
+    };
+}
+export function serializeServerError(err, dev) {
+    if (dev) {
+        return errorToJSON(err);
+    }
+    return {
+        code: 500,
+        message: 'Internal Server Error',
+        name: 'Internal Server Error'
+    };
+}

package/esm/shuvi-app/react/AppContainer.d.ts

@@ -1,6 +1,5 @@
 import * as React from 'react';
 import { IApplication } from '@shuvi/platform-shared/shared';
-export default function AppContainer({ children, app }: {
+export default function AppContainer({ app, children }: React.PropsWithChildren<{
     app: IApplication;
-    children: React.ReactElement;
-}): JSX.Element;
+}>): JSX.Element;

package/esm/shuvi-app/react/AppContainer.jsx

@@ -1,10 +1,9 @@
 import * as React from 'react';
 import { errorModel } from '@shuvi/platform-shared/shared';
-import { createContainer } from '@shuvi/redox-react';
 import { AppProvider } from './applicationContext';
 import ErrorPage from './ErrorPage';
 import { ErrorBoundary } from './ErrorBoundary';
-const { Provider, useSharedModel } = createContainer();
+import { Provider, useSharedModel } from './store';
 function ErrorGuard({ children = null }) {
     const [errorState] = useSharedModel(errorModel);
     if (errorState.error !== undefined) {
@@ -12,10 +11,10 @@ function ErrorGuard({ children = null }) {
     }
     return <>{children}</>;
 }
-export default function AppContainer({ children, app }) {
+export default function AppContainer({ app, children }) {
     return (<ErrorBoundary>
       <AppProvider app={app}>
-        <Provider storeManager={app.storeManager}>
+        <Provider store={app.store}>
           <ErrorGuard>{children}</ErrorGuard>
         </Provider>
       </AppProvider>

package/esm/shuvi-app/react/getRoutes.d.ts

@@ -1,2 +1,2 @@
-import { IPageRouteRecord, IRawPageRouteRecord } from '@shuvi/platform-shared/shared';
-export default function getRoutes(routes: IRawPageRouteRecord[]): IPageRouteRecord[];
+import { IPageRouteRecord } from '@shuvi/platform-shared/shared';
+export default function getRoutes(routes: IPageRouteRecord[]): IPageRouteRecord[];

package/esm/shuvi-app/react/getRoutes.js

@@ -13,18 +13,19 @@ import { loadRouteComponent } from './loadRouteComponent';
 export default function getRoutes(routes) {
     const getRoutesWithRequire = (routes) => routes.map(x => {
         const originalRoute = Object.assign({}, x);
-        const { __componentSource__, __componentSourceWithAffix__, __import__, __resolveWeak__, children } = originalRoute, rest = __rest(originalRoute, ["__componentSource__", "__componentSourceWithAffix__", "__import__", "__resolveWeak__", "children"]);
-        const route = Object.assign({}, rest);
+        const { __componentRawRequest__, __import__, __resolveWeak__, children } = originalRoute, route = __rest(originalRoute, ["__componentRawRequest__", "__import__", "__resolveWeak__", "children"]);
         if (children) {
             route.children = getRoutesWithRequire(children);
         }
-        if (__componentSourceWithAffix__ && __import__) {
-            route.component = loadRouteComponent(__import__, {
-                webpack: __resolveWeak__,
-                modules: [__componentSourceWithAffix__]
-            });
+        if (__import__) {
+            route.component = loadRouteComponent(__import__, Object.assign({ webpack: __resolveWeak__ }, (__componentRawRequest__ && {
+                modules: [__componentRawRequest__]
+            })));
         }
-        return Object.assign({ __componentSourceWithAffix__, __resolveWeak__ }, route);
+        if (__componentRawRequest__) {
+            route.__componentRawRequest__ = __componentRawRequest__;
+        }
+        return route;
     });
     const routesWithRequire = getRoutesWithRequire(routes || []);
     return routesWithRequire;

package/esm/shuvi-app/react/{redox-react → model}/RedoxWrapper.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="react" />
-import type { IStoreManager } from '@shuvi/redox';
+import type { RedoxStore } from '@shuvi/redox';
 export declare const RedoxWrapper: (App: any, appContext: {
-    storeManager: IStoreManager;
+    store: RedoxStore;
 }) => {
-    (appProps: any): JSX.Element;
+    (): JSX.Element;
     displayName: string;
 };

package/esm/shuvi-app/react/{redox-react → model}/RedoxWrapper.jsx

@@ -1,9 +1,9 @@
 import * as React from 'react';
 import { RedoxRoot } from '@shuvi/redox-react';
 export const RedoxWrapper = (App, appContext) => {
-    function RedoxAppWrapper(appProps) {
-        return (<RedoxRoot storeManager={appContext.storeManager}>
-        <App {...appProps}/>
+    function RedoxAppWrapper() {
+        return (<RedoxRoot store={appContext.store}>
+        <App />
       </RedoxRoot>);
     }
     RedoxAppWrapper.displayName = 'RedoxAppWrapper';

package/esm/shuvi-app/react/model/runtime.d.ts

@@ -0,0 +1,8 @@
+import { RedoxStore } from '@shuvi/redox';
+declare module '@shuvi/runtime' {
+    interface CustomAppContext {
+        store: RedoxStore;
+    }
+}
+declare const _default: import("@shuvi/platform-shared/shared").IPluginInstance<import("@shuvi/platform-shared/shared").RuntimePluginHooks, void>;
+export default _default;

package/esm/shuvi-app/react/{redox-react → model}/runtime.js

@@ -7,10 +7,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { createRuntimePlugin } from '@shuvi/platform-shared/shared';
+import { createRuntimePluginAfter } from '@shuvi/platform-shared/shared';
 import { RedoxWrapper } from './RedoxWrapper';
-export default createRuntimePlugin({
+// this needs to be run last
+export default createRuntimePluginAfter({
     appComponent: (App, appContext) => __awaiter(void 0, void 0, void 0, function* () {
-        return RedoxWrapper(App, appContext);
+        return RedoxWrapper(App, {
+            store: appContext.store
+        });
     })
+}, {
+    name: 'model-react'
 });

package/esm/shuvi-app/react/store.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+declare const Provider: (props: import("react").PropsWithChildren<{
+    store?: import("@shuvi/redox").RedoxStore | undefined;
+}>) => JSX.Element, useSharedModel: import("@shuvi/redox-react/esm/types").IUseModel, useStaticModel: import("@shuvi/redox-react/esm/types").IUseStaticModel;
+export { Provider, useSharedModel, useStaticModel };

package/esm/shuvi-app/react/store.js

@@ -0,0 +1,3 @@
+import { createContainer } from '@shuvi/redox-react';
+const { Provider, useSharedModel, useStaticModel } = createContainer();
+export { Provider, useSharedModel, useStaticModel };

package/esm/shuvi-app/react/types.d.ts

@@ -1,14 +1,7 @@
-import { IAppState } from '@shuvi/platform-shared/shared';
 import { IHtmlTag, IViewClient, IViewServer } from '../../shared';
 export { IHtmlTag };
 export declare type IReactAppData = {
-    appProps?: Record<string, any>;
-    errorProps?: {
-        notFound: boolean;
-    };
     dynamicIds?: Array<string | number>;
-    appState?: IAppState;
-    loadersData: any;
 };
 export declare type IReactServerView = IViewServer<IReactAppData>;
 export declare type IReactClientView = IViewClient<IReactAppData>;

package/esm/shuvi-app/react/useLoaderData.js

@@ -1,27 +1,16 @@
 import { useMatchedRoute } from '@shuvi/router-react';
-import { getLoaderManager } from '@shuvi/platform-shared/shared';
-import { useRef, useEffect, useReducer } from 'react';
+import { loaderModel } from '@shuvi/platform-shared/shared';
+import { useStaticModel } from './store';
 export const noLoaderMessage = 'Warning: no loader found. Please make sure the page component where `useLoaderData` is called has a `loader` export.';
+const hasOwn = Object.prototype.hasOwnProperty;
 export const useLoaderData = () => {
-    var _a;
     const currentMatch = useMatchedRoute();
-    const loaderManager = getLoaderManager();
-    const id = (_a = currentMatch.route) === null || _a === void 0 ? void 0 : _a.id;
-    const data = loaderManager.getData(id);
-    if (data === null) {
+    const id = currentMatch.route.id;
+    // we don't need to watch the model change, cause it always change with
+    // matched route
+    const [state] = useStaticModel(loaderModel);
+    if (!hasOwn.call(state.current.dataByRouteId, id)) {
         throw Error(noLoaderMessage);
     }
-    const dataRef = useRef(data);
-    const [_, forceUpdate] = useReducer(state => state * -1, 1);
-    useEffect(() => {
-        const cancel = loaderManager.subscribe(() => {
-            const newData = loaderManager.getData(id);
-            if (newData !== data) {
-                dataRef.current = newData;
-                forceUpdate();
-            }
-        });
-        return cancel;
-    }, []);
-    return dataRef.current;
+    return state.current.dataByRouteId[id];
 };

package/esm/shuvi-app/react/view/ReactView.client.jsx

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import * as React from 'react';
 import { SHUVI_ERROR } from '@shuvi/shared/lib/constants';
 import { Router } from '@shuvi/router-react';
+import { getServerError } from '@shuvi/error-overlay';
 import AppContainer from '../AppContainer';
 import { HeadManager, HeadManagerContext } from '../head';
 import Loadable from '../loadable';
@@ -20,8 +21,8 @@ export class ReactClientView {
         this._isInitialRender = true;
         this.renderApp = ({ appContainer, app, appData }) => __awaiter(this, void 0, void 0, function* () {
             const { _isInitialRender: isInitialRender } = this;
-            const { router, appComponent: AppComponent, error } = app;
-            let { ssr, appProps, dynamicIds } = appData;
+            const { router, appComponent: AppComponent, setError: setAppError, error: appError } = app;
+            let { ssr, dynamicIds } = appData;
             // For e2e test
             if (window.__SHUVI) {
                 window.__SHUVI.router = router;
@@ -29,6 +30,26 @@ export class ReactClientView {
             else {
                 window.__SHUVI = { router };
             }
+            if (process.env.NODE_ENV === 'development') {
+                if (appError && appError.source === 'server') {
+                    setTimeout(() => {
+                        var _a;
+                        let error;
+                        try {
+                            // Generate a new error object. We `throw` it because some browsers
+                            // will set the `stack` when thrown, and we want to ensure ours is
+                            // not overridden when we re-throw it below.
+                            throw new Error(appError.message);
+                        }
+                        catch (e) {
+                            error = e;
+                        }
+                        error.name = (_a = appError.name) !== null && _a !== void 0 ? _a : '';
+                        error.stack = appError.stack;
+                        throw getServerError(error);
+                    });
+                }
+            }
             const TypedAppComponent = AppComponent;
             if (ssr) {
                 yield Loadable.preloadReady(dynamicIds);
@@ -39,13 +60,13 @@ export class ReactClientView {
                 const { matches } = router.current;
                 if (!matches.length) {
                     // no handler no matches
-                    error.error(SHUVI_ERROR.PAGE_NOT_FOUND);
+                    setAppError(SHUVI_ERROR.PAGE_NOT_FOUND);
                 }
             }
             const root = (<Router router={router}>
         <AppContainer app={app}>
           <HeadManagerContext.Provider value={headManager.updateHead}>
-            <TypedAppComponent {...appProps}/>
+            <TypedAppComponent />
           </HeadManagerContext.Provider>
         </AppContainer>
       </Router>);

package/esm/shuvi-app/react/view/ReactView.server.jsx

@@ -9,32 +9,31 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import * as React from 'react';
 import { renderToString } from 'react-dom/server';
-import { getLoaderManager, redirect } from '@shuvi/platform-shared/shared';
+import { redirect } from '@shuvi/platform-shared/shared';
 import { SHUVI_ERROR } from '@shuvi/shared/lib/constants';
 import { Router } from '@shuvi/router-react';
+import chalk from '@shuvi/utils/lib/chalk';
 import Loadable, { LoadableContext } from '../loadable';
 import AppContainer from '../AppContainer';
 import { Head } from '../head';
+import { serializeServerError } from '../../helper/serializeServerError';
 export class ReactServerView {
     constructor() {
-        this.renderApp = ({ app, manifest, getAssetPublicUrl }) => __awaiter(this, void 0, void 0, function* () {
+        this.renderApp = ({ req, app, manifest, isDev }) => __awaiter(this, void 0, void 0, function* () {
             yield Loadable.preloadAll();
-            const { storeManager, router, error: appError, appComponent: AppComponent } = app;
+            const { router, appComponent: AppComponent, setError: setAppError } = app;
             yield router.ready;
             // todo: move these into renderer
             let { pathname, matches, redirected } = router.current;
             // handler no matches
             if (!matches.length) {
-                appError.error(SHUVI_ERROR.PAGE_NOT_FOUND);
+                setAppError(SHUVI_ERROR.PAGE_NOT_FOUND);
             }
             if (redirected) {
                 return redirect(pathname);
             }
-            // todo: move loader into app, avoid using global module
-            const loaderManager = getLoaderManager();
-            const loadersData = yield loaderManager.getAllData();
             const loadableModules = [];
-            let htmlContent;
+            let htmlContent = undefined;
             let head;
             const RootApp = (<Router static router={router}>
         <AppContainer app={app}>
@@ -46,8 +45,14 @@ export class ReactServerView {
             try {
                 htmlContent = renderToString(RootApp);
             }
+            catch (error) {
+                if (isDev) {
+                    console.error(chalk.red('error') + ' - ' + error.stack);
+                }
+                setAppError(serializeServerError(error, isDev));
+                htmlContent = renderToString(RootApp); // Consistency on both server and client side
+            }
             finally {
-                loaderManager.clearAllData();
                 head = Head.rewind() || [];
             }
             const { loadble } = manifest;
@@ -72,7 +77,7 @@ export class ReactServerView {
                         tagName: 'link',
                         attrs: {
                             rel: 'preload',
-                            href: getAssetPublicUrl(file),
+                            href: req.getAssetUrl(file),
                             as: 'script'
                         }
                     });
@@ -82,19 +87,17 @@ export class ReactServerView {
                         tagName: 'link',
                         attrs: {
                             rel: 'stylesheet',
-                            href: getAssetPublicUrl(file)
+                            href: req.getAssetUrl(file)
                         }
                     });
                 }
             }
             const appData = {
-                dynamicIds: [...dynamicImportIdSet],
-                loadersData
+                dynamicIds: [...dynamicImportIdSet]
             };
             if (dynamicImportIdSet.size) {
                 appData.dynamicIds = Array.from(dynamicImportIdSet);
             }
-            appData.appState = storeManager.getState();
             return {
                 appData,
                 content: htmlContent,

package/esm/shuvi-app/shuvi-runtime-index.d.ts

@@ -1,4 +1,4 @@
-import { IRequestHandlerWithNext } from '@shuvi/service';
+import { ShuviRequestHandler } from '@shuvi/service';
 import { IApiRequestHandler } from '../shared';
-export declare type MiddlewareHandler = IRequestHandlerWithNext;
-export declare type APIHandler = IApiRequestHandler;
+export declare type ShuviMiddlewareHandler = ShuviRequestHandler;
+export declare type ShuviApiHandler = IApiRequestHandler;

package/esm/shuvi-app/shuvi-runtime-index.js

@@ -1,2 +1,2 @@
-// exported by @shuvi/runtme
+// exported by @shuvi/runtime
 export {};

package/lib/node/features/custom-server/index.d.ts

@@ -1,4 +1,4 @@
 declare const _default: {
-    server: import("@shuvi/hook").IPluginInstance<import("@shuvi/service/lib/server/plugin").BuiltInServerPluginHooks & import("@shuvi/service/lib/server/pluginTypes").CustomServerPluginHooks, import("@shuvi/service").IServerPluginContext>;
+    server: import("@shuvi/hook").IPluginInstance<import("@shuvi/service/lib/server/plugin").ServerPluginHooks, import("@shuvi/service").IServerPluginContext>;
 };
 export default _default;

package/lib/node/features/custom-server/server.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("@shuvi/hook").IPluginInstance<import("@shuvi/service/lib/server/plugin").BuiltInServerPluginHooks & import("@shuvi/service/lib/server/pluginTypes").CustomServerPluginHooks, import("@shuvi/service").IServerPluginContext>;
+declare const _default: import("@shuvi/hook").IPluginInstance<import("@shuvi/service/lib/server/plugin").ServerPluginHooks, import("@shuvi/service").IServerPluginContext>;
 export default _default;

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

@@ -1,14 +1,14 @@
 /// <reference types="node" />
 import { IncomingMessage } from 'http';
-import { IResponse, IRequest } from '@shuvi/service';
+import { ShuviRequest, ShuviResponse } from '@shuvi/service';
 import { IApiRequestHandler, IApiResponse } from '../../../../shared';
 export { IApiRequestHandler };
-export declare function apiRouteHandler(req: IRequest, res: IResponse, resolver: IApiRequestHandler, apiRoutesConfig: any): Promise<void>;
+export declare function apiRouteHandler(req: ShuviRequest, res: ShuviResponse, resolver: IApiRequestHandler, apiRoutesConfig: any): Promise<void>;
 /**
  * Parse incoming message like `json` or `urlencoded`
  * @param req request object
  */
-export declare function parseBody(req: IRequest, limit: string | number): Promise<any>;
+export declare function parseBody(req: ShuviRequest, limit: string | number): Promise<any>;
 /**
  * Parse cookies from `req` header
  * @param req request object
@@ -21,27 +21,27 @@ export declare function getCookieParser(req: IncomingMessage): {
  * @param res ServerResponse object
  * @param statusCode `HTTP` status code of response
  */
-export declare function sendStatusCode<IRes extends IApiResponse>(res: IResponse, statusCode: number): IRes;
+export declare function sendStatusCode<IRes extends IApiResponse>(res: ShuviResponse, statusCode: number): IRes;
 /**
  *
  * @param res response object
  * @param [statusOrUrl] `HTTP` status code of redirect
  * @param url URL of redirect
  */
-export declare function redirect<IRes extends IApiResponse>(res: IResponse, statusOrUrl: string | number, url?: string): IRes;
+export declare function redirect<IRes extends IApiResponse>(res: ShuviResponse, statusOrUrl: string | number, url?: string): IRes;
 /**
  * Send `any` body to response
  * @param req request object
  * @param res response object
  * @param body of response
  */
-export declare function sendData(req: IRequest, res: IResponse, body: any): void;
+export declare function sendData(req: ShuviRequest, res: ShuviResponse, body: any): void;
 /**
  * Send `JSON` object
  * @param res response object
  * @param jsonBody of data
  */
-export declare function sendJson(req: IRequest, res: IResponse, jsonBody: any): void;
+export declare function sendJson(req: ShuviRequest, res: ShuviResponse, jsonBody: any): void;
 /**
  * Custom error class
  */

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

@@ -42,11 +42,7 @@ 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)
             };