@midwayjs/passport 2.14.1 → 3.0.0-beta.12

package/CHANGELOG.md

@@ -3,26 +3,55 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
-## [2.14.1](https://github.com/midwayjs/midway/compare/v2.14.0...v2.14.1) (2021-12-06)
+# [3.0.0-beta.12](https://github.com/midwayjs/midway/compare/v3.0.0-beta.11...v3.0.0-beta.12) (2021-12-28)
 
 
-### Bug Fixes
+### Features
+
+* support throw err status ([#1440](https://github.com/midwayjs/midway/issues/1440)) ([7b98110](https://github.com/midwayjs/midway/commit/7b98110d65c5287a8fcb3eb5356dea2d7a32cee9))
+
+
+
+
+
+# [3.0.0-beta.11](https://github.com/midwayjs/midway/compare/v3.0.0-beta.10...v3.0.0-beta.11) (2021-12-21)
+
+**Note:** Version bump only for package @midwayjs/passport
+
+
+
+
+
+# [3.0.0-beta.10](https://github.com/midwayjs/midway/compare/v3.0.0-beta.9...v3.0.0-beta.10) (2021-12-20)
+
+
+### Features
+
+* default add session  & bodyparser support for koa/express/faas ([#1420](https://github.com/midwayjs/midway/issues/1420)) ([cdaff31](https://github.com/midwayjs/midway/commit/cdaff317c3e862a95494a167995a28280af639bf))
+* implement i18n for validate ([#1426](https://github.com/midwayjs/midway/issues/1426)) ([4c7ed2f](https://github.com/midwayjs/midway/commit/4c7ed2ff2e7ccf10f88f62abad230f92f5e76b97))
+
+
+
+
+
+# [3.0.0-beta.9](https://github.com/midwayjs/midway/compare/v3.0.0-beta.8...v3.0.0-beta.9) (2021-12-09)
 
-* passport missing proxy file ([#1405](https://github.com/midwayjs/midway/issues/1405)) ([ded726a](https://github.com/midwayjs/midway/commit/ded726aeda756aea4dcb2c616d3bc85984e46a60))
+**Note:** Version bump only for package @midwayjs/passport
 
 
 
 
 
-# [2.14.0](https://github.com/midwayjs/midway/compare/v2.13.5...v2.14.0) (2021-12-06)
+# [3.0.0-beta.8](https://github.com/midwayjs/midway/compare/v3.0.0-beta.7...v3.0.0-beta.8) (2021-12-08)
 
 
 ### Bug Fixes
 
-* express routing middleware takes effect at the controller level ([#1364](https://github.com/midwayjs/midway/issues/1364)) ([5d5f299](https://github.com/midwayjs/midway/commit/5d5f2992be116ca71b21f01fd782e3a2ac072496))
+* express routing middleware takes effect at the controller level ([#1364](https://github.com/midwayjs/midway/issues/1364)) ([b9272e0](https://github.com/midwayjs/midway/commit/b9272e0971003443304b0c53815be31a0061b4bd))
+* passport missing proxy file ([#1405](https://github.com/midwayjs/midway/issues/1405)) ([5c9bdae](https://github.com/midwayjs/midway/commit/5c9bdae8323b41ead72c3d3f867aa11150bb3e78))
 
 
 ### Features
 
-* passport add presetProperty ([#1358](https://github.com/midwayjs/midway/issues/1358)) ([0e5e586](https://github.com/midwayjs/midway/commit/0e5e586c8a43971ff804f73000d44434ac0a9eb4))
-* support passport and jwt ([#1343](https://github.com/midwayjs/midway/issues/1343)) ([f1a7668](https://github.com/midwayjs/midway/commit/f1a7668dfce5a82ddc37efa7cd6321e088d0b1cc))
+* passport add presetProperty ([#1358](https://github.com/midwayjs/midway/issues/1358)) ([4db8eda](https://github.com/midwayjs/midway/commit/4db8eda592c0486898edabcacbc9a69eb2d87004))
+* support passport and jwt ([#1343](https://github.com/midwayjs/midway/issues/1343)) ([f26af4f](https://github.com/midwayjs/midway/commit/f26af4f3e16507d6f3ffe0467f8f5be69e6306d7))

package/README.md

@@ -87,7 +87,7 @@ import { Inject, Provide } from '@midwayjs/decorator';
 import { PassportMiddleware } from '@midwayjs/passport';
 import { Context } from '@midwayjs/express';
 
-@Provide('local') // 此处可以使用一个简短的identifier
+@Provide()
 export class LocalPassportMiddleware extends PassportMiddleware(LocalStrategy) {
   // 设置 AuthenticateOptions
   getAuthenticateOptions(): Promise<passport.AuthenticateOptions> | passport.AuthenticateOptions {
@@ -107,7 +107,7 @@ import { Provide, Post, Inject, Controller } from '@midwayjs/decorator';
 @Controller('/')
 export class LocalController {
 
-  @Post('/passport/local', { middleware: ['local'] })
+  @Post('/passport/local', { middleware: [LocalPassportMiddleware] })
   async localPassport() {
     console.log('local user: ', this.ctx.req.user);
     return this.ctx.req.user;
@@ -186,7 +186,7 @@ export class JwtController {
   @Inject()
   ctx: any;
 
-  @Post('/passport/jwt', { middleware: ['jwtPassportMiddleware'] })
+  @Post('/passport/jwt', { middleware: [JwtPassportMiddleware] })
   async jwtPassport() {
     console.log('jwt user: ', this.ctx.req.user);
     return this.ctx.req.user;
@@ -259,10 +259,10 @@ export class AuthController {
   @Inject()
   ctx: any;
 
-  @Get('/github', { middleware: ['githubPassportMiddleware'] })
+  @Get('/github', { middleware: [GithubPassportMiddleware] })
   async githubOAuth() {}
 
-  @Get('/github/cb', { middleware: ['githubPassportMiddleware'] })
+  @Get('/github/cb', { middleware: [GithubPassportMiddleware] })
   async githubOAuthCallback() {
     return this.ctx.req.user;
   }

package/dist/config/config.default.d.ts

@@ -1,5 +1,5 @@
 export declare const passport: {
     session: boolean;
-    property: string;
+    userProperty: string;
 };
 //# sourceMappingURL=config.default.d.ts.map

package/dist/config/config.default.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.passport = void 0;
 exports.passport = {
-    session: false,
-    property: 'user',
+    session: true,
+    userProperty: 'user',
 };
 //# sourceMappingURL=config.default.js.map

package/dist/configuration.d.ts

@@ -1,5 +1,7 @@
-import { ILifeCycle, IMidwayApplication, IMidwayContainer } from '@midwayjs/core';
-export declare class PassportConfiguration implements ILifeCycle {
-    onReady(container: IMidwayContainer, app: IMidwayApplication): Promise<void>;
+import { IMidwayContainer, MidwayApplicationManager, MidwayConfigService } from '@midwayjs/core';
+export declare class PassportConfiguration {
+    applicationManager: MidwayApplicationManager;
+    configService: MidwayConfigService;
+    onReady(container: IMidwayContainer): Promise<void>;
 }
 //# sourceMappingURL=configuration.d.ts.map

package/dist/configuration.js

@@ -5,16 +5,37 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PassportConfiguration = void 0;
 const decorator_1 = require("@midwayjs/decorator");
 const DefaultConfig = require("./config/config.default");
-const passport_1 = require("./service/passport");
+const util_1 = require("./util");
+const core_1 = require("@midwayjs/core");
 let PassportConfiguration = class PassportConfiguration {
-    async onReady(container, app) {
-        await container.getAsync(passport_1.PassportService);
+    async onReady(container) {
+        const passportConfig = this.configService.getConfiguration('passport');
+        const passport = (0, util_1.getPassport)();
+        this.applicationManager
+            .getApplications(['express', 'koa', 'egg', 'faas'])
+            .forEach(app => {
+            app.useMiddleware(passport.initialize());
+            if (passportConfig.session) {
+                app.useMiddleware(passport.session());
+            }
+        });
     }
 };
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", core_1.MidwayApplicationManager)
+], PassportConfiguration.prototype, "applicationManager", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", core_1.MidwayConfigService)
+], PassportConfiguration.prototype, "configService", void 0);
 PassportConfiguration = __decorate([
     (0, decorator_1.Configuration)({
         namespace: 'passport',

package/dist/proxy/framework/koa.js

@@ -39,6 +39,10 @@ function initialize(passport) {
         const login = req.login;
         ctx.login = ctx.logIn = function (user, options) {
             return new Promise((resolve, reject) => {
+                // fix session manager missing
+                if (!req._sessionManager) {
+                    req._sessionManager = passport._sm;
+                }
                 login.call(req, user, options, err => {
                     if (err)
                         reject(err);

package/dist/service/passport.d.ts

@@ -2,12 +2,5 @@ import * as passport from 'passport';
 import { AbstractPassportMiddleware, AbstractStrategy } from '../interface';
 export declare function PassportStrategy(Strategy: new (...args: any[]) => passport.Strategy, name?: string): new (...args: any[]) => AbstractStrategy;
 export declare type StrategyClass = new (...args: any[]) => AbstractStrategy;
-export declare function PassportMiddleware(type: StrategyClass | StrategyClass[]): new (...args: any[]) => AbstractPassportMiddleware;
-export declare class PassportService {
-    passportConfig: any;
-    app: any;
-    inited: boolean;
-    initMiddleware(): void;
-    authenticate(strategy: StrategyClass | StrategyClass[], options: passport.AuthenticateOptions): any;
-}
+export declare function PassportMiddleware(strategy: StrategyClass | StrategyClass[]): new (...args: any[]) => AbstractPassportMiddleware;
 //# sourceMappingURL=passport.d.ts.map

package/dist/service/passport.js

@@ -9,192 +9,105 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PassportService = exports.PassportMiddleware = exports.PassportStrategy = void 0;
+exports.PassportMiddleware = exports.PassportStrategy = void 0;
 const decorator_1 = require("@midwayjs/decorator");
 const util_1 = require("../util");
 const interface_1 = require("../interface");
 function PassportStrategy(Strategy, name) {
     class InnerStrategyAbstractClass extends interface_1.AbstractStrategy {
-        constructor() {
-            super(...arguments);
-            this.inited = false;
-        }
-        async initStrategy() {
-            if (!this.inited) {
-                this.inited = true;
-                const cb = async (...params) => {
-                    const done = params[params.length - 1];
-                    try {
-                        const result = await this.validate(...params);
-                        if (Array.isArray(result)) {
-                            done(null, ...result);
-                        }
-                        else {
-                            done(null, result);
-                        }
+        async init() {
+            const cb = async (...params) => {
+                const done = params[params.length - 1];
+                try {
+                    const result = await this.validate(...params);
+                    if (Array.isArray(result)) {
+                        done(null, ...result);
                     }
-                    catch (err) {
-                        done(err, null);
+                    else {
+                        done(null, result);
                     }
-                };
-                this.strategy = new Strategy(this.getStrategyOptions(), cb);
-                const passport = (0, util_1.getPassport)();
-                if (name) {
-                    passport.use(name, this.strategy);
-                }
-                else {
-                    passport.use(this.strategy);
-                }
-                if (this['serializeUser']) {
-                    passport.serializeUser(this['serializeUser']);
                 }
-                if (this['deserializeUser']) {
-                    passport.deserializeUser(this['deserializeUser']);
-                }
-                if (this['transformAuthInfo']) {
-                    passport.transformAuthInfo(this['transformAuthInfo']);
+                catch (err) {
+                    done(err, null);
                 }
+            };
+            this.strategy = new Strategy(this.getStrategyOptions(), cb);
+            const passport = (0, util_1.getPassport)();
+            if (name) {
+                passport.use(name, this.strategy);
+            }
+            else {
+                passport.use(this.strategy);
+            }
+            if (this['serializeUser']) {
+                passport.serializeUser(this['serializeUser']);
+            }
+            if (this['deserializeUser']) {
+                passport.deserializeUser(this['deserializeUser']);
+            }
+            if (this['transformAuthInfo']) {
+                passport.transformAuthInfo(this['transformAuthInfo']);
             }
         }
         getStrategy() {
             return this.strategy;
         }
     }
+    __decorate([
+        (0, decorator_1.Init)(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", Promise)
+    ], InnerStrategyAbstractClass.prototype, "init", null);
     return InnerStrategyAbstractClass;
 }
 exports.PassportStrategy = PassportStrategy;
-function PassportMiddleware(type) {
+function PassportMiddleware(strategy) {
     class InnerPassportMiddleware extends interface_1.AbstractPassportMiddleware {
-        authenticate(options) {
-            return this.passportService.authenticate(type, options);
-        }
         resolve() {
-            this.passportService.initMiddleware();
             if ((0, util_1.isExpressMode)()) {
-                return async (req, res, next) => {
+                return async function passportMiddleware(req, res, next) {
                     return this.authenticate(await this.getAuthenticateOptions())(req, res, next);
-                };
+                }.bind(this);
             }
             else {
-                return async (ctx, next) => {
+                return async function passportMiddleware(ctx, next) {
                     return this.authenticate(await this.getAuthenticateOptions())(ctx, next);
-                };
+                }.bind(this);
             }
         }
         getAuthenticateOptions() {
             return undefined;
         }
-    }
-    __decorate([
-        (0, decorator_1.Inject)(),
-        __metadata("design:type", PassportService)
-    ], InnerPassportMiddleware.prototype, "passportService", void 0);
-    return InnerPassportMiddleware;
-}
-exports.PassportMiddleware = PassportMiddleware;
-let PassportService = class PassportService {
-    constructor() {
-        this.inited = false;
-    }
-    initMiddleware() {
-        if (!this.inited) {
-            this.inited = true;
-            const passport = (0, util_1.getPassport)();
-            this.app.use(passport.initialize());
-            if (this.passportConfig.session) {
-                this.app.use(passport.session());
+        authenticate(options) {
+            if (!Array.isArray(strategy)) {
+                strategy = [strategy];
             }
-        }
-    }
-    authenticate(strategy, options) {
-        if (!Array.isArray(strategy)) {
-            strategy = [strategy];
-        }
-        if ((0, util_1.isExpressMode)()) {
-            return async (req, res, next) => {
-                // merge options with default options
-                const authOptions = {
-                    ...this.passportConfig,
-                    ...options,
-                };
-                if (authOptions.session && req.session[authOptions.property]) {
-                    req[authOptions.property] = req.session[authOptions.property];
-                }
-                // ignore user has exists
-                if (req[authOptions.property]) {
-                    next();
-                }
-                else {
-                    const passport = (0, util_1.getPassport)();
-                    const strategyList = [];
-                    for (const strategySingle of strategy) {
-                        // got strategy
-                        const strategyInstance = await this.app
-                            .getApplicationContext()
-                            .getAsync(strategySingle);
-                        await strategyInstance.initStrategy();
-                        strategyList.push(strategyInstance.getStrategy());
+            if ((0, util_1.isExpressMode)()) {
+                return async (req, res, next) => {
+                    // merge options with default options
+                    const authOptions = {
+                        ...this.passportConfig,
+                        ...options,
+                    };
+                    if (authOptions.session && req.session[authOptions.userProperty]) {
+                        req[authOptions.userProperty] =
+                            req.session[authOptions.userProperty];
                     }
-                    const user = await new Promise((resolve, reject) => {
-                        // authenticate
-                        passport.authenticate(strategyList, authOptions, (err, user, info, status) => {
-                            if (err) {
-                                reject(err);
-                            }
-                            else {
-                                resolve(user);
-                            }
-                        })(req, res, err => (err ? reject(err) : resolve(0)));
-                    });
-                    if (user) {
-                        req[authOptions.property] = user;
-                        if (authOptions.session) {
-                            req.logIn(user, options, next);
-                            return;
-                        }
+                    // ignore user has exists
+                    if (req[authOptions.userProperty]) {
+                        next();
                     }
                     else {
-                        if (options.failureRedirect) {
-                            res.redirect(options.failureRedirect);
-                            return;
+                        const passport = (0, util_1.getPassport)();
+                        const strategyList = [];
+                        for (const strategySingle of strategy) {
+                            // got strategy
+                            const strategyInstance = await this.app
+                                .getApplicationContext()
+                                .getAsync(strategySingle);
+                            strategyList.push(strategyInstance.getStrategy());
                         }
-                        else {
-                            res.status(401);
-                        }
-                    }
-                    next();
-                }
-            };
-        }
-        else {
-            return async (ctx, next) => {
-                // merge options with default options
-                const authOptions = {
-                    ...this.passportConfig,
-                    ...options,
-                };
-                if (authOptions.session &&
-                    ctx.session.passport &&
-                    ctx.session.passport[authOptions.property]) {
-                    ctx.state[authOptions.property] =
-                        ctx.session.passport[authOptions.property];
-                }
-                // ignore user has exists
-                if (ctx.state[authOptions.property]) {
-                    await next();
-                }
-                else {
-                    const passport = (0, util_1.getPassport)();
-                    const strategyList = [];
-                    for (const strategySingle of strategy) {
-                        // got strategy
-                        const strategyInstance = await this.app
-                            .getApplicationContext()
-                            .getAsync(strategySingle);
-                        await strategyInstance.initStrategy();
-                        strategyList.push(strategyInstance.getStrategy());
-                    }
-                    try {
                         const user = await new Promise((resolve, reject) => {
                             // authenticate
                             passport.authenticate(strategyList, authOptions, (err, user, info, status) => {
@@ -204,49 +117,109 @@ let PassportService = class PassportService {
                                 else {
                                     resolve(user);
                                 }
-                            })(ctx, err => (err ? reject(err) : resolve(0)));
+                            })(req, res, err => (err ? reject(err) : resolve(0)));
                         });
                         if (user) {
-                            ctx.state[authOptions.property] = user;
+                            req[authOptions.userProperty] = user;
                             if (authOptions.session) {
-                                // save to ctx.session.passport
-                                await ctx.login(user, options);
-                            }
-                            if (options.successRedirect) {
-                                ctx.redirect(options.successRedirect);
+                                req.logIn(user, options, next);
                                 return;
                             }
                         }
                         else {
                             if (options.failureRedirect) {
-                                ctx.redirect(options.failureRedirect);
+                                res.redirect(options.failureRedirect);
                                 return;
                             }
                             else {
-                                ctx.status = 401;
+                                res.status(401);
                             }
                         }
+                        next();
+                    }
+                };
+            }
+            else {
+                return async function bbb(ctx, next) {
+                    // merge options with default options
+                    const authOptions = {
+                        ...this.passportConfig,
+                        ...options,
+                    };
+                    if (authOptions.session &&
+                        ctx.session.passport &&
+                        ctx.session.passport[authOptions.userProperty]) {
+                        ctx.state[authOptions.userProperty] =
+                            ctx.session.passport[authOptions.userProperty];
+                    }
+                    // ignore user has exists
+                    if (ctx.state[authOptions.userProperty]) {
                         await next();
                     }
-                    catch (err) {
-                        ctx.throw(err);
+                    else {
+                        const passport = (0, util_1.getPassport)();
+                        const strategyList = [];
+                        for (const strategySingle of strategy) {
+                            // got strategy
+                            const strategyInstance = await this.app
+                                .getApplicationContext()
+                                .getAsync(strategySingle);
+                            strategyList.push(strategyInstance.getStrategy());
+                        }
+                        try {
+                            const user = await new Promise((resolve, reject) => {
+                                // authenticate
+                                passport.authenticate(strategyList, authOptions, (err, user, info, status) => {
+                                    if (err) {
+                                        reject(err);
+                                    }
+                                    else {
+                                        resolve(user);
+                                    }
+                                })(ctx, err => (err ? reject(err) : resolve(0)));
+                            });
+                            if (user) {
+                                ctx.state[authOptions.userProperty] = user;
+                                if (authOptions.session) {
+                                    // save to ctx.session.passport
+                                    await ctx.login(user, options);
+                                }
+                                if (options.successRedirect) {
+                                    ctx.redirect(options.successRedirect);
+                                    return;
+                                }
+                            }
+                            else {
+                                if (options.failureRedirect) {
+                                    ctx.redirect(options.failureRedirect);
+                                    return;
+                                }
+                                else {
+                                    ctx.status = 401;
+                                }
+                            }
+                            await next();
+                        }
+                        catch (err) {
+                            ctx.throw(err);
+                        }
                     }
-                }
-            };
+                }.bind(this);
+            }
+        }
+        static getName() {
+            return 'passport';
         }
     }
-};
-__decorate([
-    (0, decorator_1.Config)('passport'),
-    __metadata("design:type", Object)
-], PassportService.prototype, "passportConfig", void 0);
-__decorate([
-    (0, decorator_1.App)(),
-    __metadata("design:type", Object)
-], PassportService.prototype, "app", void 0);
-PassportService = __decorate([
-    (0, decorator_1.Provide)(),
-    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton)
-], PassportService);
-exports.PassportService = PassportService;
+    __decorate([
+        (0, decorator_1.Config)('passport'),
+        __metadata("design:type", Object)
+    ], InnerPassportMiddleware.prototype, "passportConfig", void 0);
+    __decorate([
+        (0, decorator_1.App)(),
+        __metadata("design:type", Object)
+    ], InnerPassportMiddleware.prototype, "app", void 0);
+    return InnerPassportMiddleware;
+}
+exports.PassportMiddleware = PassportMiddleware;
 //# sourceMappingURL=passport.js.map

package/index.d.ts

@@ -0,0 +1,57 @@
+import * as passport from 'passport';
+
+export * from './dist/index';
+
+declare module '@midwayjs/core/dist/interface' {
+  interface MidwayConfig {
+    passport?: passport.AuthenticateOptions;
+  }
+}
+
+declare module '@midwayjs/koa/dist/interface' {
+  interface Context {
+    state: {
+      user?: any;
+    };
+    isAuthenticated(): boolean;
+    isUnauthenticated(): boolean;
+    login(): Promise<void>;
+    logout(): void;
+  }
+}
+
+declare module '@midwayjs/web/dist/interface' {
+  interface Context {
+    state: {
+      user?: any;
+    };
+    isAuthenticated(): boolean;
+    isUnauthenticated(): boolean;
+    login(): Promise<void>;
+    logout(): void;
+  }
+}
+
+declare module '@midwayjs/faas/dist/interface' {
+  interface Context {
+    state: {
+      user?: any;
+    };
+    isAuthenticated(): boolean;
+    isUnauthenticated(): boolean;
+    login(): Promise<void>;
+    logout(): void;
+  }
+}
+
+declare module '@midwayjs/express/dist/interface' {
+  interface Context {
+    user?: any;
+    // These declarations are merged into express's Request type
+    login(user: any, done: (err: any) => void): void;
+    login(user: any, options: any, done: (err: any) => void): void;
+    logout(): void;
+    isAuthenticated(): boolean;
+    isUnauthenticated(): boolean;
+  }
+}

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@midwayjs/passport",
   "description": "midway passport component",
-  "version": "2.14.1",
+  "version": "3.0.0-beta.12",
   "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "typings": "index.d.ts",
   "files": [
     "dist/**/*.js",
-    "dist/**/*.d.ts"
+    "dist/**/*.d.ts",
+    "index.d.ts"
   ],
   "scripts": {
     "build": "tsc",
@@ -21,21 +22,22 @@
   "author": "Nawbc",
   "license": "MIT",
   "devDependencies": {
-    "@midwayjs/core": "^2.14.0",
-    "@midwayjs/decorator": "^2.14.0",
-    "@midwayjs/express": "^2.14.0",
-    "@midwayjs/jwt": "^2.14.0",
-    "@midwayjs/koa": "^2.14.0",
-    "@midwayjs/mock": "^2.14.0",
-    "@midwayjs/web": "^2.14.0",
+    "@midwayjs/core": "^3.0.0-beta.12",
+    "@midwayjs/decorator": "^3.0.0-beta.12",
+    "@midwayjs/express": "^3.0.0-beta.12",
+    "@midwayjs/jwt": "^3.0.0-beta.12",
+    "@midwayjs/koa": "^3.0.0-beta.12",
+    "@midwayjs/mock": "^3.0.0-beta.12",
+    "@midwayjs/web": "^3.0.0-beta.12",
     "@types/passport": "^1.0.7",
     "@types/passport-local": "^1.0.34",
     "express-session": "^1.17.2",
     "passport": "^0.5.0",
+    "passport-jwt": "^4.0.0",
     "passport-local": "^1.0.0"
   },
   "peerDependencies": {
     "passport": "^0.5.0"
   },
-  "gitHead": "b3dc5e27f4d611880e9525a3b798b99b349c3dd5"
+  "gitHead": "1c46e53eb934248007eeb7fe3920f5ac24e272c6"
 }