@midwayjs/passport 2.13.3

package/README.md

@@ -0,0 +1,275 @@
+# @midwayjs/passport
+
+身份验证是大多数Web应用程序的重要组成部分。因此Midway封装了目前Nodejs中最流行的Passport库。
+Passport是通过称为策略的可扩展插件进行身份验证请求。Passport 不挂载路由或假设任何特定的数据库，这最大限度地提高了灵活性并允许开发人员做出应用程序级别的决策。
+
+
+## 准备
+
+
+1. 安装 `npm i @midwayjs/passport`
+
+
+
+```bash
+$ npm i passport --save
+$ npm i @types/passport --save-dev
+```
+
+2. 如果有需要的话，开启相对应框架的 bodyparser，session
+
+
+## 使用
+
+这里我们以本地认证，和Jwt作为演示。
+
+
+首先
+```bash
+// configuration.ts
+
+import { join } from 'path';
+import * as jwt from '@midwayjs/jwt';
+import { ILifeCycle,} from '@midwayjs/core';
+import { Configuration } from '@midwayjs/decorator';
+import * as passport from '@midwayjs/passport';
+
+@Configuration({
+  imports: [
+    jwt,
+    passport,
+  ],
+  importConfigs: [join(__dirname, './config')],
+  conflictCheck: true,
+})
+export class ContainerLifeCycle implements ILifeCycle {}
+
+```
+### e.g. 本地
+我们可以通过`@CuustomStrategy`和派生`PassportStrategy`来自启动一个策略。通过 validate 钩子来获取有效负载，并且此函数必须有返回值，其参数并不明确，可以参考对应的Strategy或者通过展开符打印查看。
+```typescript
+// local-strategy.ts
+
+import { CustomStrategy, PassportStrategy } from '@midwayjs/passport';
+import { Repository } from 'typeorm';
+import { InjectEntityModel } from '@midwayjs/orm';
+import { UserEntity } from './user';
+import * as bcrypt from 'bcrypt';
+
+@CustomStrategy()
+export class LocalStrategy extends PassportStrategy(Strategy) {
+  @InjectEntityModel(UserEntity)
+  userModel: Repository<UserEntity>;
+
+  // 策略的验证
+  async validate(username, password) {
+    const user = await this.userModel.findOne({ username });
+    if (await bcrypt.compare(password, user.password)) {
+      throw new Error('error password ' + username);
+    }
+
+    return {
+      username,
+      password,
+    };
+  }
+
+  // 当前策略的参数
+  getStrategyOptions(): any {
+    return {};
+  }
+}
+
+```
+使用派生`PassportMiddleware`出一个中间件。
+```typescript
+// local-middleware.ts
+
+import { Inject, Provide } from '@midwayjs/decorator';
+import { PassportMiddleware } from '@midwayjs/passport';
+import { Context } from '@midwayjs/express';
+
+@Provide('local') // 此处可以使用一个简短的identifier
+export class LocalPassportMiddleware extends PassportMiddleware(LocalStrategy) {
+  // 设置 AuthenticateOptions
+  getAuthenticateOptions(): Promise<passport.AuthenticateOptions> | passport.AuthenticateOptions {
+    return {
+      failureRedirect: '/login',
+      presetProperty: 'user'
+    };
+  }
+}
+```
+```typescript
+// controller.ts
+
+import { Provide, Post, Inject, Controller } from '@midwayjs/decorator';
+
+@Provide()
+@Controller('/')
+export class LocalController {
+
+  @Post('/passport/local', { middleware: ['local'] })
+  async localPassport() {
+    console.log('local user: ', this.ctx.req.user);
+    return this.ctx.req.user;
+  }
+}
+```
+使用curl 模拟一次请求。
+```bash
+curl -X POST http://localhost:7001/passport/local -d '{"username": "demo", "password": "1234"}' -H "Content-Type: application/json"
+
+结果 {"username": "demo", "password": "1234"}
+```
+### e.g. Jwt
+首先你需要安装`npm i @midwayjs/jwt`，然后在 config.ts 中配置。PS.  默认未加密，请不要吧敏感信息存放在payload中。
+```typescript
+export const jwt = {
+	secret: 'xxxxxxxxxxxxxx', // fs.readFileSync('xxxxx.key')
+  expiresIn: '2d'   // https://github.com/vercel/ms
+}
+```
+```typescript
+// strategy/jwt-strategy.ts
+
+import { CustomStrategy, PassportStrategy } from '@midwayjs/passport';
+import { Strategy, ExtractJwt } from 'passport-jwt';
+
+@CustomStrategy()
+export class JwtStrategy extends PassportStrategy(
+  Strategy,
+  'jwt'
+) {
+  @Config('jwt')
+  jwtConfig;
+
+  async validate(payload) {
+    return payload;
+  }
+
+  getStrategyOptions(): any {
+    return {
+      secretOrKey: this.jwtConfig.secret,
+      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+    };
+  }
+}
+
+
+```
+```typescript
+// jwt-middleware.ts
+
+import { Provide } from '@midwayjs/decorator';
+import { PassportMiddleware } from '@midwayjs/passport';
+import { JwtStrategy } from './strategy/jwt-strategy';
+
+@Provide()
+export class JwtPassportMiddleware extends PassportMiddleware(JwtStrategy) {
+  getAuthenticateOptions(): Promise<passport.AuthenticateOptions> | passport.AuthenticateOptions {
+    return {};
+  }
+}
+
+```
+```typescript
+import { Provide, Post, Inject } from '@midwayjs/decorator';
+import { Controller, Post } from '@midwayjs/decorator';
+import { Jwt } from '@midwayjs/jwt';
+
+@Provide()
+@Controller('/')
+export class JwtController {
+
+  @Inject()
+  jwt: Jwt;
+
+  @Inject()
+  ctx: any;
+
+  @Post('/passport/jwt', { middleware: ['jwtPassportMiddleware'] })
+  async jwtPassport() {
+    console.log('jwt user: ', this.ctx.req.user);
+    return this.ctx.req.user;
+  }
+
+  @Post('/jwt')
+  async genJwt() {
+    return {
+      t: await this.jwt.sign({ msg: 'Hello Midway' }),
+    };
+  }
+}
+```
+使用curl模拟请求
+```bash
+curl -X POST http://127.0.0.1:7001/jwt
+
+结果 {"t": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"}
+
+curl http://127.0.0.1:7001/passport/jwt -H "Authorization: Bearer xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+
+结果 {"msg": "Hello Midway","iat": 1635468727,"exp": 1635468827}
+
+```
+## 自定义其他策略
+
+
+`@midwayjs/passport`支持自定义[其他策略](http://www.passportjs.org/packages/)，这里以github oauth为例。
+首先 `npm i passport-github`，之后编写如下代码：
+```typescript
+// github-strategy.ts
+
+import { CustomStrategy, PassportStrategy } from '@midwayjs/passport';
+import { Strategy, StrategyOptions } from 'passport-github';
+
+const GITHUB_CLIENT_ID = 'xxxxxx', GITHUB_CLIENT_SECRET = 'xxxxxxxx';
+
+@CustomStrategy()
+export class GithubStrategy extends PassportStrategy(Strategy, 'github') {
+  async validate(...payload) {
+    return payload;
+  }
+  getStrategyOptions() {
+    return {
+      clientID: GITHUB_CLIENT_ID,
+      clientSecret: GITHUB_CLIENT_SECRET,
+      callbackURL: 'https://127.0.0.1:7001/auth/github/cb'
+    };
+  }
+}
+
+```
+```typescript
+// github-middleware.ts
+
+import { PassportMiddleware } from '@midwayjs/passport';
+
+@Provide()
+export class GithubPassportMiddleware extends PassportMiddleware {
+}
+```
+```typescript
+// controller.ts
+
+import { Provide, Get, Inject } from '@midwayjs/decorator';
+
+@Provide()
+@Controller('/oauth')
+export class AuthController {
+  @Inject()
+  ctx: any;
+
+  @Get('/github', { middleware: ['githubPassportMiddleware'] })
+  async githubOAuth() {}
+
+  @Get('/github/cb', { middleware: ['githubPassportMiddleware'] })
+  async githubOAuthCallback() {
+    return this.ctx.req.user;
+  }
+}
+
+```
+
+

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

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

package/dist/config/config.default.js

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

package/dist/configuration.d.ts

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

package/dist/configuration.js

@@ -0,0 +1,29 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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;
+};
+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");
+let PassportConfiguration = class PassportConfiguration {
+    async onReady(container, app) {
+        await container.getAsync(passport_1.PassportService);
+    }
+};
+PassportConfiguration = __decorate([
+    (0, decorator_1.Configuration)({
+        namespace: 'passport',
+        importConfigs: [
+            {
+                default: DefaultConfig,
+            },
+        ],
+    })
+], PassportConfiguration);
+exports.PassportConfiguration = PassportConfiguration;
+//# sourceMappingURL=configuration.js.map

package/dist/decorator/strategy.d.ts

@@ -0,0 +1,2 @@
+export declare function CustomStrategy(): ClassDecorator;
+//# sourceMappingURL=strategy.d.ts.map

package/dist/decorator/strategy.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomStrategy = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+function CustomStrategy() {
+    return target => {
+        (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton)(target);
+        (0, decorator_1.Provide)()(target);
+    };
+}
+exports.CustomStrategy = CustomStrategy;
+//# sourceMappingURL=strategy.js.map

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { PassportConfiguration as Configuration } from './configuration';
+export * from './decorator/strategy';
+export * from './service/passport';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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.Configuration = void 0;
+var configuration_1 = require("./configuration");
+Object.defineProperty(exports, "Configuration", { enumerable: true, get: function () { return configuration_1.PassportConfiguration; } });
+__exportStar(require("./decorator/strategy"), exports);
+__exportStar(require("./service/passport"), exports);
+//# sourceMappingURL=index.js.map

package/dist/interface.d.ts

@@ -0,0 +1,20 @@
+import * as passport from 'passport';
+export interface IPassportStrategy {
+    validate(...args: any[]): any;
+    getStrategyOptions(): any;
+    serializeUser?(user: any, done: (err: any, id?: any) => void): void;
+    deserializeUser?(id: any, done: (err: any, user?: any) => void): void;
+    transformAuthInfo?(info: any, done: (err: any, info: any) => void): void;
+}
+export declare abstract class AbstractStrategy implements IPassportStrategy {
+    abstract validate(...args: any[]): any;
+    abstract getStrategyOptions(): any;
+}
+export interface IPassportMiddleware {
+    authenticate?(options: passport.AuthenticateOptions, callback: Function): any;
+}
+export declare abstract class AbstractPassportMiddleware implements IPassportMiddleware {
+    abstract getAuthenticateOptions(): Promise<passport.AuthenticateOptions> | passport.AuthenticateOptions;
+    authenticate?(options: passport.AuthenticateOptions, callback?: Function): any;
+}
+//# sourceMappingURL=interface.d.ts.map

package/dist/interface.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractPassportMiddleware = exports.AbstractStrategy = void 0;
+class AbstractStrategy {
+}
+exports.AbstractStrategy = AbstractStrategy;
+class AbstractPassportMiddleware {
+}
+exports.AbstractPassportMiddleware = AbstractPassportMiddleware;
+//# sourceMappingURL=interface.js.map

package/dist/service/passport.d.ts

@@ -0,0 +1,13 @@
+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;
+}
+//# sourceMappingURL=passport.d.ts.map

package/dist/service/passport.js

@@ -0,0 +1,252 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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.PassportService = 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);
+                        }
+                    }
+                    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;
+        }
+    }
+    return InnerStrategyAbstractClass;
+}
+exports.PassportStrategy = PassportStrategy;
+function PassportMiddleware(type) {
+    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 this.authenticate(await this.getAuthenticateOptions())(req, res, next);
+                };
+            }
+            else {
+                return async (ctx, next) => {
+                    return this.authenticate(await this.getAuthenticateOptions())(ctx, next);
+                };
+            }
+        }
+        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(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());
+                    }
+                    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;
+                        }
+                    }
+                    else {
+                        if (options.failureRedirect) {
+                            res.redirect(options.failureRedirect);
+                            return;
+                        }
+                        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) => {
+                                if (err) {
+                                    reject(err);
+                                }
+                                else {
+                                    resolve(user);
+                                }
+                            })(ctx, err => (err ? reject(err) : resolve(0)));
+                        });
+                        if (user) {
+                            ctx.state[authOptions.property] = 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);
+                    }
+                }
+            };
+        }
+    }
+};
+__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;
+//# sourceMappingURL=passport.js.map

package/dist/util.d.ts

@@ -0,0 +1,3 @@
+export declare function getPassport(): any;
+export declare function isExpressMode(): boolean;
+//# sourceMappingURL=util.d.ts.map

package/dist/util.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExpressMode = exports.getPassport = void 0;
+const core_1 = require("@midwayjs/core");
+function getPassport() {
+    return isExpressMode() ? require('passport') : require('./proxy/index');
+}
+exports.getPassport = getPassport;
+function isExpressMode() {
+    var _a;
+    return !!((_a = process.env['MIDWAY_PASSPORT_MODE'] === 'express') !== null && _a !== void 0 ? _a : (0, core_1.safeRequire)('@midwayjs/express'));
+}
+exports.isExpressMode = isExpressMode;
+//# sourceMappingURL=util.js.map

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@midwayjs/passport",
+  "description": "midway passport component",
+  "version": "2.13.3",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "node --require=ts-node/register ../../node_modules/jest/bin/jest.js",
+    "cov": "node --require=ts-node/register ../../node_modules/.bin/jest --coverage --forceExit"
+  },
+  "keywords": [
+    "midway",
+    "authorization",
+    "passport"
+  ],
+  "author": "Nawbc",
+  "license": "MIT",
+  "devDependencies": {
+    "@midwayjs/core": "^2.13.4",
+    "@midwayjs/decorator": "^2.13.2",
+    "@midwayjs/express": "^2.13.4",
+    "@midwayjs/koa": "^2.13.4",
+    "@midwayjs/mock": "^2.13.4",
+    "@midwayjs/web": "^2.13.4",
+    "@midwayjs/jwt": "^2.13.4",
+    "@types/passport": "^1.0.7",
+    "@types/passport-local": "^1.0.34",
+    "passport": "^0.5.0",
+    "passport-local": "^1.0.0",
+    "express-session": "^1.17.2"
+  },
+  "peerDependencies": {
+    "passport": "^0.5.0"
+  }
+}