@shuvi/service 1.0.0 → 1.0.2

package/lib/bundler/bundler.d.ts

@@ -16,7 +16,7 @@ export interface NormalizedBundlerOptions {
     ignoreTypeScriptErrors: boolean;
 }
 export declare type BundlerOptions = Partial<NormalizedBundlerOptions>;
-export interface Bunlder {
+export interface Bundler {
     targets: Target[];
     watching: Watching;
     watch(): Watching;
@@ -32,9 +32,9 @@ export interface CompilerStats {
     warnings: CompilerErr[];
 }
 export declare type FinishedCallback = (stats: CompilerStats) => any;
-export interface BunlderEvent {
+export interface BundlerEvent {
     'build-done': (stats: CompilerStats) => void;
     'ts-error': (err: CompilerErr) => void;
     'ts-warnings': (warnings: CompilerErr[]) => void;
 }
-export declare function getBundler(ctx: IPluginContext): Promise<Bunlder>;
+export declare function getBundler(ctx: IPluginContext): Promise<Bundler>;

package/lib/bundler/bundler.js

@@ -392,7 +392,9 @@ class WebpackBundler {
 function getBundler(ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
-            yield (0, typescript_1.setupTypeScript)(ctx.paths, ctx.mode === 'production');
+            yield (0, typescript_1.setupTypeScript)(ctx.paths, {
+                reportMissingError: ctx.mode === 'production'
+            });
             const options = Object.assign(Object.assign({}, defaultBundleOptions), { preBundle: ctx.config.experimental.preBundle, ignoreTypeScriptErrors: ctx.config.typescript.ignoreBuildErrors });
             if (ctx.mode !== 'development') {
                 options.preBundle = false;

package/lib/bundler/config.js

@@ -36,7 +36,7 @@ function createWebpackConfig({ mode, assetPublicPath, paths, config }, _a) {
     const lightningCss = !!config.experimental.lightningCss;
     const experimental = config.experimental;
     const compiler = Object.assign(Object.assign({}, config.compiler), { modularizeImports: experimental.modularizeImports, swcPlugins: experimental.swcPlugins });
-    const typescript = (0, typescript_1.getTypeScriptInfo)();
+    const jsConfig = (0, typescript_1.getJavaScriptInfo)();
     if (opts.node) {
         chain = (0, config_1.createNodeWebpackChain)({
             name,
@@ -47,7 +47,7 @@ function createWebpackConfig({ mode, assetPublicPath, paths, config }, _a) {
             publicPath,
             lightningCss,
             compiler,
-            typescript,
+            jsConfig,
             include,
             env,
             webpackHelpers
@@ -63,7 +63,7 @@ function createWebpackConfig({ mode, assetPublicPath, paths, config }, _a) {
             publicPath,
             lightningCss,
             compiler,
-            typescript,
+            jsConfig,
             include,
             env,
             webpackHelpers,

package/lib/bundler/index.d.ts

@@ -1,3 +1,3 @@
 export { BundlerResult } from './runCompiler';
-export { getBundler, Bunlder } from './bundler';
+export { getBundler, Bundler } from './bundler';
 export { Watching } from './watchingProxy';

package/lib/bundler/typescript/{getTypeScriptInfo.d.ts → checkDependencies.d.ts}

@@ -1,4 +1,3 @@
-import { TsConfig, TypeScriptModule } from './types';
 export interface PackageDep {
     file: string;
     pkg: string;
@@ -7,7 +6,6 @@ export declare type CheckedDependenciesResult = {
     resovled: Map<string, string>;
     missing: PackageDep[];
 };
+export declare function resolveDependencies(dir: string, deps: PackageDep[]): CheckedDependenciesResult;
 export declare function hasTypescriptFiles(projectDir: string): Promise<boolean>;
 export declare function checkNecessaryDeps(projectDir: string): CheckedDependenciesResult;
-export declare function hasTsConfig(tsConfigPath: string): Promise<boolean>;
-export declare function getTsConfig(ts: TypeScriptModule, tsConfigPath: string): Promise<TsConfig>;

package/lib/bundler/typescript/checkDependencies.js

@@ -0,0 +1,61 @@
+"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.checkNecessaryDeps = exports.hasTypescriptFiles = exports.resolveDependencies = void 0;
+const fs_extra_1 = require("fs-extra");
+const resolve_1 = require("@shuvi/utils/lib/resolve");
+const recursiveReaddir_1 = require("@shuvi/utils/lib/recursiveReaddir");
+const requiredPackages = [
+    { file: 'typescript', pkg: 'typescript' },
+    { file: '@types/react/index.d.ts', pkg: '@types/react' },
+    { file: '@types/react-dom/index.d.ts', pkg: '@types/react-dom' },
+    { file: '@types/node/index.d.ts', pkg: '@types/node' }
+];
+function resolveDependencies(dir, deps) {
+    let resolutions = new Map();
+    const missingPackages = deps.filter(p => {
+        try {
+            resolutions.set(p.pkg, (0, resolve_1.resolve)(p.file, { basedir: dir }));
+            return false;
+        }
+        catch (_) {
+            return true;
+        }
+    });
+    return {
+        resovled: resolutions,
+        missing: missingPackages
+    };
+}
+exports.resolveDependencies = resolveDependencies;
+function hasTypescriptFiles(projectDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const stats = yield (0, fs_extra_1.stat)(projectDir);
+            if (!stats.isDirectory()) {
+                return false;
+            }
+        }
+        catch (error) {
+            return false;
+        }
+        const typescriptFiles = yield (0, recursiveReaddir_1.recursiveReadDir)(projectDir, {
+            filter: /.*\.(ts|tsx)$/,
+            ignore: /(\.shuvi)|(node_modules|.*\.d\.ts)/
+        });
+        return typescriptFiles.length > 0;
+    });
+}
+exports.hasTypescriptFiles = hasTypescriptFiles;
+function checkNecessaryDeps(projectDir) {
+    return resolveDependencies(projectDir, requiredPackages);
+}
+exports.checkNecessaryDeps = checkNecessaryDeps;

package/lib/bundler/typescript/configTypeScript.d.ts

@@ -1,3 +1,3 @@
 import { IPaths } from '../../core/apiTypes';
-import { TypeScriptModule, TsConfig } from './types';
-export declare function writeDefaultConfigurations(ts: TypeScriptModule, tsConfigPath: string, tsConfig: TsConfig, paths: IPaths, isFirstTimeSetup: boolean): Promise<void>;
+import { TypeScriptModule, TsParsedConfig } from './types';
+export declare function writeDefaultConfigurations(ts: TypeScriptModule, tsConfigPath: string, tsConfig: TsParsedConfig, paths: IPaths, isFirstTimeSetup: boolean): Promise<void>;

package/lib/bundler/typescript/getTsConfig.d.ts

@@ -0,0 +1,4 @@
+import { TsParsedConfig, TypeScriptModule } from './types';
+export declare function hasTypescriptFiles(projectDir: string): Promise<boolean>;
+export declare function hasTsConfig(tsConfigPath: string): Promise<boolean>;
+export declare function getTsConfig(ts: TypeScriptModule, tsConfigPath: string): Promise<TsParsedConfig>;

package/lib/bundler/typescript/{getTypeScriptInfo.js → getTsConfig.js}

@@ -12,36 +12,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTsConfig = exports.hasTsConfig = exports.checkNecessaryDeps = exports.hasTypescriptFiles = void 0;
+exports.getTsConfig = exports.hasTsConfig = exports.hasTypescriptFiles = void 0;
 const fs_extra_1 = require("fs-extra");
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const chalk_1 = __importDefault(require("@shuvi/utils/lib/chalk"));
 const logger_1 = __importDefault(require("@shuvi/utils/lib/logger"));
-const resolve_1 = require("@shuvi/utils/lib/resolve");
 const recursiveReaddir_1 = require("@shuvi/utils/lib/recursiveReaddir");
-const requiredPackages = [
-    { file: 'typescript', pkg: 'typescript' },
-    { file: '@types/react/index.d.ts', pkg: '@types/react' },
-    { file: '@types/react-dom/index.d.ts', pkg: '@types/react-dom' },
-    { file: '@types/node/index.d.ts', pkg: '@types/node' }
-];
-function checkDependencies(dir, deps) {
-    let resolutions = new Map();
-    const missingPackages = deps.filter(p => {
-        try {
-            resolutions.set(p.pkg, (0, resolve_1.resolve)(p.file, { basedir: dir }));
-            return false;
-        }
-        catch (_) {
-            return true;
-        }
-    });
-    return {
-        resovled: resolutions,
-        missing: missingPackages
-    };
-}
 function hasTypescriptFiles(projectDir) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
@@ -61,10 +38,6 @@ function hasTypescriptFiles(projectDir) {
     });
 }
 exports.hasTypescriptFiles = hasTypescriptFiles;
-function checkNecessaryDeps(projectDir) {
-    return checkDependencies(projectDir, requiredPackages);
-}
-exports.checkNecessaryDeps = checkNecessaryDeps;
 function hasTsConfig(tsConfigPath) {
     return __awaiter(this, void 0, void 0, function* () {
         const hasTsConfig = yield (0, fs_extra_1.pathExists)(tsConfigPath);

package/lib/bundler/typescript/index.d.ts

@@ -1,2 +1,2 @@
-export { setupTypeScript, getTypeScriptInfo } from './setupTypeScript';
+export { setupTypeScript, getJavaScriptInfo, JavaScriptInfo as TypeScriptInfo, ParsedJsConfig, loadJsConfig } from './setupTypeScript';
 export * from './types';

package/lib/bundler/typescript/index.js

@@ -14,8 +14,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTypeScriptInfo = exports.setupTypeScript = void 0;
+exports.loadJsConfig = exports.getJavaScriptInfo = exports.setupTypeScript = void 0;
 var setupTypeScript_1 = require("./setupTypeScript");
 Object.defineProperty(exports, "setupTypeScript", { enumerable: true, get: function () { return setupTypeScript_1.setupTypeScript; } });
-Object.defineProperty(exports, "getTypeScriptInfo", { enumerable: true, get: function () { return setupTypeScript_1.getTypeScriptInfo; } });
+Object.defineProperty(exports, "getJavaScriptInfo", { enumerable: true, get: function () { return setupTypeScript_1.getJavaScriptInfo; } });
+Object.defineProperty(exports, "loadJsConfig", { enumerable: true, get: function () { return setupTypeScript_1.loadJsConfig; } });
 __exportStar(require("./types"), exports);

package/lib/bundler/typescript/setupTypeScript.d.ts

@@ -1,12 +1,23 @@
 import { IPaths } from '../../core/apiTypes';
-import { TsCompilerOptions } from './types';
-interface TypeScriptInfo {
+import { TsCompilerOptions, TsParsedConfig } from './types';
+export interface JavaScriptInfo {
     useTypeScript: boolean;
     typeScriptPath?: string;
-    tsConfigPath?: string;
-    tsCompilerOptions: TsCompilerOptions;
-    resolvedBaseUrl?: string;
+    compilerOptions: TsCompilerOptions;
+    resolvedBaseUrl: string;
 }
-export declare function getTypeScriptInfo(): TypeScriptInfo;
-export declare function setupTypeScript(paths: IPaths, reportMissingError?: Boolean): Promise<void>;
-export {};
+export interface ParsedJsConfig {
+    useTypescript: boolean;
+    tsParsedConfig?: TsParsedConfig;
+    compilerOptions: TsCompilerOptions;
+    resolvedBaseUrl: string;
+}
+export declare function getJavaScriptInfo(): JavaScriptInfo;
+export declare function loadJsConfig(projectDir: string, { typeScriptPath, typescript }: {
+    typeScriptPath?: string;
+    typescript?: boolean;
+}): Promise<ParsedJsConfig>;
+export declare function setupTypeScript(paths: IPaths, { reportMissingError, enableTypeScript }: {
+    reportMissingError: boolean;
+    enableTypeScript?: boolean;
+}): Promise<void>;

package/lib/bundler/typescript/setupTypeScript.js

@@ -35,20 +35,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setupTypeScript = exports.getTypeScriptInfo = void 0;
+exports.setupTypeScript = exports.loadJsConfig = exports.getJavaScriptInfo = void 0;
 const path = __importStar(require("path"));
 const chalk_1 = __importDefault(require("@shuvi/utils/lib/chalk"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const error_1 = require("../../error");
 const getPkgManager_1 = require("../helper/getPkgManager");
 const configTypeScript_1 = require("./configTypeScript");
-const getTypeScriptInfo_1 = require("./getTypeScriptInfo");
+const getTsConfig_1 = require("./getTsConfig");
+const checkDependencies_1 = require("./checkDependencies");
 const installDependencies_1 = require("./installDependencies");
 let hasSetup = false;
 let useTypeScript;
+let compilerOptions;
 let typeScriptPath;
-let tsConfigPath;
-let tsCompilerOptions;
+let typescriptModule;
 let resolvedBaseUrl;
 function missingPackagesError(dir, pkgs) {
     const packageManager = (0, getPkgManager_1.getPkgManager)(dir);
@@ -80,30 +81,63 @@ function missingPackagesError(dir, pkgs) {
         removalMsg +
         '\n');
 }
-function getTypeScriptInfo() {
+function getJavaScriptInfo() {
     if (!hasSetup) {
-        throw error_1.Error.Fatal("please call 'setupTypeScript' before calling 'getTypeScriptInfo'");
+        throw error_1.Error.Fatal("please call 'setupTypeScript' before calling 'getJavaScriptInfo'");
     }
     return {
         useTypeScript,
         typeScriptPath,
-        tsConfigPath,
-        tsCompilerOptions,
+        compilerOptions,
         resolvedBaseUrl
     };
 }
-exports.getTypeScriptInfo = getTypeScriptInfo;
-function setupTypeScript(paths, reportMissingError = false) {
+exports.getJavaScriptInfo = getJavaScriptInfo;
+function loadJsConfig(projectDir, { typeScriptPath, typescript = false }) {
     return __awaiter(this, void 0, void 0, function* () {
-        if (hasSetup) {
-            return;
+        let useTypescript = typescript;
+        let tsParsedConfig;
+        let compilerOptions = {};
+        let resolvedBaseUrl;
+        if (useTypeScript) {
+            const tsConfigPath = path.join(projectDir, 'tsconfig.json');
+            if (!typeScriptPath) {
+                const deps = (0, checkDependencies_1.resolveDependencies)(projectDir, [
+                    { file: 'typescript', pkg: 'typescript' }
+                ]);
+                typeScriptPath = deps.resovled.get('typescript');
+            }
+            if (typeScriptPath && (yield (0, getTsConfig_1.hasTsConfig)(tsConfigPath))) {
+                const typescriptModule = require(typeScriptPath);
+                tsParsedConfig = yield (0, getTsConfig_1.getTsConfig)(typescriptModule, tsConfigPath);
+                compilerOptions = tsParsedConfig.options;
+            }
+        }
+        else {
+            const jsConfigPath = path.join(projectDir, 'jsconfig.json');
+            if (yield fs_extra_1.default.pathExists(jsConfigPath)) {
+                const jsConfig = yield fs_extra_1.default.readJSON(jsConfigPath);
+                compilerOptions = jsConfig.compilerOptions;
+            }
+        }
+        if (compilerOptions === null || compilerOptions === void 0 ? void 0 : compilerOptions.baseUrl) {
+            resolvedBaseUrl = path.resolve(projectDir, compilerOptions.baseUrl);
         }
+        else {
+            resolvedBaseUrl = projectDir;
+        }
+        return { useTypescript, tsParsedConfig, compilerOptions, resolvedBaseUrl };
+    });
+}
+exports.loadJsConfig = loadJsConfig;
+function setupTypeScript(paths, { reportMissingError = false, enableTypeScript }) {
+    return __awaiter(this, void 0, void 0, function* () {
         hasSetup = true;
+        useTypeScript = enableTypeScript || (yield (0, getTsConfig_1.hasTypescriptFiles)(paths.srcDir));
         const projectDir = paths.rootDir;
-        useTypeScript = yield (0, getTypeScriptInfo_1.hasTypescriptFiles)(paths.srcDir);
-        tsCompilerOptions = {};
+        let parsedJsConfig;
         if (useTypeScript) {
-            let deps = (0, getTypeScriptInfo_1.checkNecessaryDeps)(projectDir);
+            let deps = (0, checkDependencies_1.checkNecessaryDeps)(projectDir);
             if (deps.missing.length > 0) {
                 if (reportMissingError) {
                     missingPackagesError(projectDir, deps.missing);
@@ -124,29 +158,27 @@ function setupTypeScript(paths, reportMissingError = false) {
                     }
                     throw err;
                 });
-                deps = (0, getTypeScriptInfo_1.checkNecessaryDeps)(projectDir);
+                deps = (0, checkDependencies_1.checkNecessaryDeps)(projectDir);
             }
             typeScriptPath = deps.resovled.get('typescript');
-            tsConfigPath = path.join(projectDir, 'tsconfig.json');
-            const needDefaultTsConfig = !(yield (0, getTypeScriptInfo_1.hasTsConfig)(tsConfigPath));
+            const tsConfigPath = path.join(projectDir, 'tsconfig.json');
+            const needDefaultTsConfig = !(yield (0, getTsConfig_1.hasTsConfig)(tsConfigPath));
             if (needDefaultTsConfig) {
                 console.log(chalk_1.default.cyan(`We detected TypeScript in your project and created a ${chalk_1.default.bold('tsconfig.json')} file for you.`));
                 console.log();
                 yield fs_extra_1.default.writeJson(tsConfigPath, {});
             }
-            const ts = require(typeScriptPath);
-            const tsConfig = yield (0, getTypeScriptInfo_1.getTsConfig)(ts, tsConfigPath);
-            tsCompilerOptions = tsConfig.options;
-            yield (0, configTypeScript_1.writeDefaultConfigurations)(ts, tsConfigPath, tsConfig, paths, needDefaultTsConfig);
-        }
-        const jsConfigPath = path.join(projectDir, 'jsconfig.json');
-        if (!useTypeScript && (yield fs_extra_1.default.pathExists(jsConfigPath))) {
-            const userJsConfig = yield fs_extra_1.default.readJSON(jsConfigPath);
-            tsCompilerOptions = userJsConfig.compilerOptions;
+            typescriptModule = require(typeScriptPath);
+            parsedJsConfig = yield loadJsConfig(projectDir, {
+                typescript: true
+            });
+            yield (0, configTypeScript_1.writeDefaultConfigurations)(typescriptModule, tsConfigPath, parsedJsConfig.tsParsedConfig, paths, needDefaultTsConfig);
         }
-        if (tsCompilerOptions === null || tsCompilerOptions === void 0 ? void 0 : tsCompilerOptions.baseUrl) {
-            resolvedBaseUrl = path.resolve(projectDir, tsCompilerOptions.baseUrl);
+        else {
+            parsedJsConfig = yield loadJsConfig(projectDir, { typescript: false });
         }
+        compilerOptions = parsedJsConfig.compilerOptions;
+        resolvedBaseUrl = parsedJsConfig.resolvedBaseUrl;
     });
 }
 exports.setupTypeScript = setupTypeScript;

package/lib/bundler/typescript/types.d.ts

@@ -1,3 +1,3 @@
 export declare type TypeScriptModule = typeof import('typescript');
-export declare type TsConfig = import('typescript').ParsedCommandLine;
+export declare type TsParsedConfig = import('typescript').ParsedCommandLine;
 export declare type TsCompilerOptions = import('typescript').CompilerOptions;

package/lib/core/api.d.ts

@@ -1,5 +1,5 @@
 import { FileOption } from '../project';
-import { Bunlder } from '../bundler';
+import { Bundler } from '../bundler';
 import { ServerPluginInstance } from '../server';
 import { ShuviConfig, IPluginConfig, IPresetConfig, IServiceMode, IServicePhase, IPlatform, IPlatformContent, IPluginContext, RuntimePluginConfig } from './apiTypes';
 interface IApiOPtions {
@@ -48,7 +48,7 @@ declare class Api {
     get pluginContext(): IPluginContext;
     get serverConfigs(): ServerConfigs;
     init(): Promise<void>;
-    getBundler(): Promise<Bunlder>;
+    getBundler(): Promise<Bundler>;
     get assetPublicPath(): string;
     buildApp(): Promise<void>;
     addRuntimeFile(option: FileOption<any>): void;

package/lib/index.d.ts

@@ -1,6 +1,6 @@
 export * from './namespace';
 export * from './constants';
-export { Bunlder } from './bundler';
+export { Bundler } from './bundler';
 export { ProjectBuilder } from './project';
 export { IShuviServer, ShuviRequest, ShuviResponse, IServerPluginContext, ShuviRequestHandler, ServerPluginConstructor, ServerPluginInstance, IServerMiddleware, createShuviServer, createServerPlugin, createServerPluginBefore, createServerPluginAfter } from './server';
 export { Api, IPaths, ShuviConfig, IServicePhase, IServiceMode, IPluginConfig, IPresetConfig, PresetFunction, IPresetContent, NormalizedShuviConfig, IPluginContext, IPlatform, IPlatformContent, CorePluginConstructor, CorePluginInstance, getApi, createPlugin, createPluginBefore, createPluginAfter, ResolvedPlugin } from './core';

package/lib/server/http-server/router.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRouter = void 0;
+const util_1 = require("util");
 const utils_1 = require("@shuvi/utils");
 const invariant_1 = __importDefault(require("@shuvi/utils/lib/invariant"));
 const router_1 = require("@shuvi/router");
@@ -35,14 +36,14 @@ class RouterImpl {
     }
     handleRequest(req, res, out) {
         let index = 0;
-        let done = (err) => out(err);
+        let done = err => out(err);
         const next = err => {
             // next callback
             const route = this._routes[index++];
             // all done
             if (!route) {
                 // final function handler
-                setImmediate(done, err);
+                this._handleError(done, err);
                 return;
             }
             const { path, handler } = route;
@@ -67,33 +68,46 @@ class RouterImpl {
             req.params = match.params;
             // call the route handler
             if (err) {
-                this._callRouteErrorHandler(handler, err, req, res, next);
+                this._callRouteErrorHandler(handler, err, req, res, next, done);
             }
             else {
-                this._callRouteRequestHandler(handler, req, res, next);
+                this._callRouteRequestHandler(handler, req, res, next, done);
             }
         };
         return next();
     }
-    _callRouteRequestHandler(handler, req, res, next) {
+    _handleError(done, err) {
+        setImmediate(done, err);
+    }
+    _callRouteRequestHandler(handler, req, res, next, done) {
         if (handler.length > 3) {
             // not a standard request handler
             return next();
         }
         try {
-            handler(req, res, next);
+            const result = handler(req, res, next);
+            if (util_1.types.isPromise(result)) {
+                result.catch(err => {
+                    this._handleError(done, err);
+                });
+            }
         }
         catch (err) {
             next(err);
         }
     }
-    _callRouteErrorHandler(handler, error, req, res, next) {
+    _callRouteErrorHandler(handler, error, req, res, next, done) {
         if (handler.length !== 4) {
             // not a standard error handler
             return next(error);
         }
         try {
-            handler(error, req, res, next);
+            const result = handler(error, req, res, next);
+            if (util_1.types.isPromise(result)) {
+                result.catch(err => {
+                    this._handleError(done, err);
+                });
+            }
         }
         catch (err) {
             next(err);

package/lib/server/index.d.ts

@@ -1,13 +1,13 @@
 import { IPluginContext } from '../core';
 import { IShuviServer, ShuviServerOptions, ShuviRequest, ShuviResponse, ShuviRequestHandler } from './shuviServerTypes';
-import { Bunlder } from '../bundler';
+import { Bundler } from '../bundler';
 export { Server } from './http-server';
 export * from './plugin';
 export * from './shuviServerTypes';
 export { ShuviRequest, ShuviResponse, ShuviRequestHandler };
 export interface CreateShuviDevServerOptions extends ShuviServerOptions {
     context: IPluginContext;
-    bundler: Bunlder;
+    bundler: Bundler;
     dev: true;
 }
 export interface CreateShuviProdServerOptions extends ShuviServerOptions {

package/lib/server/middlewares/dev/devMiddleware.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import { IncomingMessage } from 'http';
-import { Bunlder } from '../../../bundler';
+import { Bundler } from '../../../bundler';
 import { Server } from '../../http-server';
 import { IServerPluginContext } from '../../plugin';
 export interface DevMiddleware {
@@ -11,4 +11,4 @@ export interface DevMiddleware {
     waitUntilValid(force?: boolean): void;
     onHMR(req: IncomingMessage, socket: any, head: Buffer): void;
 }
-export declare function getDevMiddleware(bundler: Bunlder, serverPluginContext: IServerPluginContext): DevMiddleware;
+export declare function getDevMiddleware(bundler: Bundler, serverPluginContext: IServerPluginContext): DevMiddleware;

package/lib/server/middlewares/getAssetMiddleware.d.ts

@@ -1,3 +1,3 @@
 import { IServerPluginContext } from '../plugin';
 import { ShuviRequestHandler } from '../../server';
-export declare const getAssetMiddleware: (context: IServerPluginContext, isDev?: boolean) => ShuviRequestHandler;
+export declare const getAssetMiddleware: (context: IServerPluginContext) => ShuviRequestHandler;

package/lib/server/middlewares/getAssetMiddleware.js

@@ -12,27 +12,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAssetMiddleware = void 0;
 const constants_1 = require("../../constants");
 const utils_1 = require("../utils");
-const getAssetMiddleware = (context, isDev = false) => {
+const getAssetMiddleware = (context) => {
     return (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
-        const fullUrl = new URL(req.url, `http://${req.headers.host}`);
-        let assetPath = fullUrl.pathname;
         const candidatePaths = [];
-        if (context.assetPublicPath.startsWith('/')) {
-            assetPath = assetPath.replace(context.assetPublicPath, '');
-            candidatePaths.push(context.resolveBuildFile(constants_1.CLIENT_OUTPUT_DIR, assetPath));
-        }
-        else {
-            fullUrl.search = '';
-            const urlWithoutQuery = fullUrl.toString();
-            // when assetPublicPath is http:localhost:3000/xx
-            if (urlWithoutQuery.startsWith(context.assetPublicPath)) {
-                assetPath = urlWithoutQuery.replace(context.assetPublicPath, '');
+        try {
+            const fullUrl = new URL(req.url, `http://${req.headers.host}`);
+            let assetPath = fullUrl.pathname;
+            if (context.assetPublicPath.startsWith('/')) {
+                assetPath = assetPath.replace(context.assetPublicPath, '');
                 candidatePaths.push(context.resolveBuildFile(constants_1.CLIENT_OUTPUT_DIR, assetPath));
             }
-        }
-        if (isDev) {
+            else {
+                fullUrl.search = '';
+                const urlWithoutQuery = fullUrl.toString();
+                // when assetPublicPath is http:localhost:3000/xx
+                if (urlWithoutQuery.startsWith(context.assetPublicPath)) {
+                    assetPath = urlWithoutQuery.replace(context.assetPublicPath, '');
+                    candidatePaths.push(context.resolveBuildFile(constants_1.CLIENT_OUTPUT_DIR, assetPath));
+                }
+            }
             candidatePaths.push(context.resolvePublicFile(assetPath));
         }
+        catch (err) {
+            return next(err);
+        }
         if (!candidatePaths.length) {
             return next();
         }

package/lib/server/shuviDevServer.d.ts

@@ -6,6 +6,7 @@ export declare class ShuviDevServer extends ShuviServer {
     private verifyingTypeScript?;
     constructor(corePluginContext: any, { bundler, ...options }: ShuviDevServerOptions);
     init(): Promise<void>;
+    private _catchUnexpectedError;
     private _setupWebSocketHandler;
     private startWatcher;
     private verifyTypeScript;

package/lib/server/shuviDevServer.js

@@ -45,6 +45,7 @@ class ShuviDevServer extends shuviServer_1.ShuviServer {
                 }
             });
         };
+        this._catchUnexpectedError();
         this._bundler = bundler;
     }
     init() {
@@ -80,7 +81,7 @@ class ShuviDevServer extends shuviServer_1.ShuviServer {
             }
             // keep the order
             devMiddleware.apply(server);
-            server.use((0, getAssetMiddleware_1.getAssetMiddleware)(context, true));
+            server.use((0, getAssetMiddleware_1.getAssetMiddleware)(context));
             yield this._initMiddlewares();
             // setup upgrade listener eagerly when we can otherwise
             // it will be done on the first request via req.socket.server
@@ -88,6 +89,14 @@ class ShuviDevServer extends shuviServer_1.ShuviServer {
             yield this.startWatcher(devMiddleware);
         });
     }
+    _catchUnexpectedError() {
+        process.on('unhandledRejection', reason => {
+            console.error(`Caught unhandledRejection: \n`, reason, '\n');
+        });
+        process.on('uncaughtException', err => {
+            console.error(`Caught uncaughtException: \n`, err, '\n');
+        });
+    }
     startWatcher(devMiddleware) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this._webpackWatcher) {
@@ -98,8 +107,8 @@ class ShuviDevServer extends shuviServer_1.ShuviServer {
             const directories = [routesDir];
             const fileWatchTimes = new Map();
             const configs = this._bundler.targets;
-            let { useTypeScript } = (0, typescript_1.getTypeScriptInfo)();
-            let enabledTypeScript = useTypeScript;
+            let { useTypeScript } = (0, typescript_1.getJavaScriptInfo)();
+            let enableTypeScript = useTypeScript;
             const envFiles = [
                 '.env.development.local',
                 '.env.local',
@@ -134,23 +143,52 @@ class ShuviDevServer extends shuviServer_1.ShuviServer {
                         }
                         continue;
                     }
+                    if (tsconfigPaths.includes(fileName)) {
+                        if (fileName.endsWith('tsconfig.json') &&
+                            fileWatchTimes.get(fileName)) {
+                            enableTypeScript = true;
+                        }
+                        if (watchTimeChange) {
+                            tsconfigChange = true;
+                        }
+                        continue;
+                    }
                     if (fileName.endsWith('.ts') || fileName.endsWith('.tsx')) {
-                        enabledTypeScript = true;
+                        enableTypeScript = true;
                     }
                 }
-                if (!useTypeScript && enabledTypeScript) {
-                    yield this.verifyTypeScript();
+                if (!useTypeScript && enableTypeScript) {
+                    yield this.verifyTypeScript(enableTypeScript);
                     useTypeScript = true;
                     tsconfigChange = true;
                 }
                 if (tsconfigChange || envChange) {
+                    let parseJsConfig;
+                    if (tsconfigChange) {
+                        parseJsConfig = yield (0, typescript_1.loadJsConfig)(rootDir, { typescript: true });
+                    }
                     if (envChange) {
                         (0, env_1.loadDotenvConfig)({ rootDir, forceReloadEnv: true });
                     }
                     configs.forEach(({ config }) => {
-                        var _a;
+                        var _a, _b, _c;
+                        if (tsconfigChange) {
+                            (_b = (_a = config.resolve) === null || _a === void 0 ? void 0 : _a.plugins) === null || _b === void 0 ? void 0 : _b.forEach((plugin) => {
+                                // look for the JsConfigPathsPlugin and update with the latest paths/baseUrl config
+                                if (plugin && plugin.jsConfigPlugin && parseJsConfig) {
+                                    const { resolvedBaseUrl, compilerOptions } = parseJsConfig;
+                                    if (compilerOptions.paths && resolvedBaseUrl) {
+                                        Object.keys(plugin.paths).forEach(key => {
+                                            delete plugin.paths[key];
+                                        });
+                                        plugin.paths = Object.assign({}, compilerOptions.paths);
+                                        plugin.resolvedBaseUrl = resolvedBaseUrl;
+                                    }
+                                }
+                            });
+                        }
                         if (envChange) {
-                            (_a = config.plugins) === null || _a === void 0 ? void 0 : _a.forEach((plugin) => {
+                            (_c = config.plugins) === null || _c === void 0 ? void 0 : _c.forEach((plugin) => {
                                 // we look for the DefinePlugin definitions so we can
                                 // update them on the active compilers
                                 if (plugin &&
@@ -172,14 +210,17 @@ class ShuviDevServer extends shuviServer_1.ShuviServer {
             }));
         });
     }
-    verifyTypeScript() {
+    verifyTypeScript(enableTypeScript) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.verifyingTypeScript) {
                 return;
             }
             try {
                 this.verifyingTypeScript = true;
-                yield (0, typescript_1.setupTypeScript)(this._serverContext.paths);
+                yield (0, typescript_1.setupTypeScript)(this._serverContext.paths, {
+                    reportMissingError: false,
+                    enableTypeScript: enableTypeScript
+                });
             }
             finally {
                 this.verifyingTypeScript = false;

package/lib/server/shuviServer.js

@@ -14,6 +14,7 @@ const string_1 = require("@shuvi/utils/lib/string");
 const serverMiddleware_1 = require("./serverMiddleware");
 const http_server_1 = require("./http-server");
 const plugin_1 = require("./plugin");
+const utils_1 = require("./utils");
 class ShuviServer {
     constructor(corePluginContext, options) {
         this._pluginManager = (0, plugin_1.getManager)();
@@ -28,6 +29,8 @@ class ShuviServer {
             const fullAssetPath = (0, string_1.joinPath)(this._serverContext.assetPublicPath, assetPath);
             return fullAssetPath;
         };
+        // Parsing of cookies
+        shuviReq.cookies = (0, utils_1.getCookieParser)(req);
     }
     _normalizeResp(_resp) {
         // do nothing

package/lib/server/shuviServerTypes.d.ts

@@ -2,14 +2,16 @@
 import { RequestListener } from 'http';
 import { ServerPluginInstance } from './plugin';
 import { IPlatformContent } from '../core';
-import { Bunlder } from '../bundler';
+import { Bundler } from '../bundler';
 import { IRequest, IResponse, IRequestHandlerWithNext } from '../server/http-server';
+import type { getCookieParser } from './utils';
 export interface CustomShuviRequest {
 }
 export interface CustomShuviResponse {
 }
 export interface ShuviRequest extends IRequest, CustomShuviRequest {
     getAssetUrl(assetPath: string): string;
+    cookies: ReturnType<typeof getCookieParser>;
 }
 export interface ShuviResponse extends IResponse, CustomShuviResponse {
 }
@@ -26,5 +28,5 @@ export interface ShuviServerOptions {
     getMiddlewaresBeforeDevMiddlewares?: IPlatformContent['getMiddlewaresBeforeDevMiddlewares'];
 }
 export interface ShuviDevServerOptions extends ShuviServerOptions {
-    bundler: Bunlder;
+    bundler: Bundler;
 }

package/lib/server/utils.d.ts

@@ -2,4 +2,11 @@
 import { IncomingMessage, ServerResponse } from 'http';
 export declare function isStaticFileExist(path: string): Boolean;
 export declare function serveStatic(req: IncomingMessage, res: ServerResponse, path: string): Promise<void>;
+/**
+ * Parse cookies from `req` header
+ * @param req request object
+ */
+export declare function getCookieParser(req: IncomingMessage): {
+    [key: string]: string;
+};
 export declare function sendHTML(req: IncomingMessage, res: ServerResponse, html: string): void;

package/lib/server/utils.js

@@ -1,11 +1,35 @@
 "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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendHTML = exports.serveStatic = exports.isStaticFileExist = void 0;
+exports.sendHTML = exports.getCookieParser = exports.serveStatic = exports.isStaticFileExist = void 0;
 const fs_1 = require("fs");
 const send_1 = __importDefault(require("send"));
+const cookie = __importStar(require("cookie"));
 function isStaticFileExist(path) {
     if ((0, fs_1.existsSync)(path)) {
         return !(0, fs_1.statSync)(path).isDirectory() && (0, fs_1.statSync)(path).isFile();
@@ -31,6 +55,18 @@ function serveStatic(req, res, path) {
     });
 }
 exports.serveStatic = serveStatic;
+/**
+ * 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;
 function sendHTML(req, res, html) {
     if (res.writableEnded || res.headersSent)
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shuvi/service",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/shuvijs/shuvi.git",
@@ -29,13 +29,13 @@
     "@babel/generator": "7.14.5",
     "@babel/parser": "7.14.7",
     "@babel/traverse": "7.14.7",
-    "@shuvi/hook": "1.0.0",
-    "@shuvi/router": "1.0.0",
-    "@shuvi/runtime": "1.0.0",
-    "@shuvi/shared": "1.0.0",
-    "@shuvi/toolpack": "1.0.0",
-    "@shuvi/utils": "1.0.0",
-    "@shuvi/error-overlay": "1.0.0",
+    "@shuvi/hook": "1.0.2",
+    "@shuvi/router": "1.0.2",
+    "@shuvi/runtime": "1.0.2",
+    "@shuvi/shared": "1.0.2",
+    "@shuvi/toolpack": "1.0.2",
+    "@shuvi/utils": "1.0.2",
+    "@shuvi/error-overlay": "1.0.2",
     "commander": "5.1.0",
     "comment-json": "4.2.2",
     "cross-spawn": "7.0.3",
@@ -43,6 +43,7 @@
     "fs-extra": "9.0.1",
     "http-proxy-middleware": "1.0.6",
     "rimraf": "3.0.2",
+    "cookie": "0.4.1",
     "send": "0.17.1",
     "ws": "8.2.3",
     "dotenv": "16.0.3",
@@ -55,6 +56,7 @@
     "@types/babel__traverse": "^7.14.2",
     "@types/cross-spawn": "6.0.1",
     "@types/detect-port": "1.3.0",
+    "@types/cookie": "^0.4.1",
     "@types/ejs": "3.0.4",
     "@types/ws": "8.2.0"
   }