@midwayjs/passport 3.4.0-beta.7 → 3.4.0

package/dist/passport/passport.service.js

@@ -0,0 +1,393 @@
+"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.PassportMiddleware = exports.PassportStrategy = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+const interface_1 = require("../interface");
+const core_1 = require("@midwayjs/core");
+const authenticator_1 = require("./authenticator");
+const strategy_1 = require("./strategy");
+const request_1 = require("./request");
+function PassportStrategy(Strategy, name) {
+    class InnerStrategyAbstractClass extends strategy_1.AbstractStrategyWrapper {
+        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);
+                    }
+                    else {
+                        done(null, result);
+                    }
+                }
+                catch (err) {
+                    done(err, null);
+                }
+            };
+            this.strategy = new Strategy(this.getStrategyOptions(), cb);
+            if (name) {
+                this.passport.use(name, this.strategy);
+            }
+            else {
+                this.passport.use(this.strategy);
+            }
+            if (this['serializeUser']) {
+                this.passport.serializeUser(this['serializeUser']);
+            }
+            if (this['deserializeUser']) {
+                this.passport.deserializeUser(this['deserializeUser']);
+            }
+            if (this['transformAuthInfo']) {
+                this.passport.transformAuthInfo(this['transformAuthInfo']);
+            }
+        }
+        getStrategy() {
+            return this.strategy;
+        }
+    }
+    __decorate([
+        (0, decorator_1.Inject)(),
+        __metadata("design:type", authenticator_1.PassportAuthenticator)
+    ], InnerStrategyAbstractClass.prototype, "passport", void 0);
+    __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(strategy) {
+    class InnerPassportMiddleware extends interface_1.AbstractPassportMiddleware {
+        resolve() {
+            return this.authenticate(this.getAuthenticateOptions());
+        }
+        getAuthenticateOptions() {
+            return undefined;
+        }
+        authenticate(options) {
+            if (!Array.isArray(strategy)) {
+                strategy = [strategy];
+            }
+            if (this.passport.isExpressMode()) {
+                return async function passportAuthenticate(req, res, next) {
+                    // init req method
+                    this.attachRequestMethod(req);
+                    // merge options with default options
+                    const authOptions = {
+                        ...this.passportConfig,
+                        ...options,
+                    };
+                    const strategyList = [];
+                    for (const strategySingle of strategy) {
+                        // got strategy
+                        const strategyInstance = await this.app
+                            .getApplicationContext()
+                            .getAsync(strategySingle);
+                        strategyList.push(strategyInstance.getStrategy());
+                    }
+                    // authenticate
+                    const authenticate = this.passport.authenticate(strategyList, authOptions);
+                    const authenticateResult = await authenticate(req);
+                    // success
+                    if (authenticateResult.successResult) {
+                        const breakNext = await this.onceSucceed(options, authenticateResult.successResult.user, authenticateResult.successResult.info, req, res);
+                        if (breakNext) {
+                            return;
+                        }
+                    }
+                    else if (authenticateResult.redirectResult) {
+                        // redirect
+                        res.statusCode = authenticateResult.redirectResult.status || 302;
+                        res.setHeader('Location', authenticateResult.redirectResult.url);
+                        res.setHeader('Content-Length', '0');
+                        res.end();
+                        return;
+                    }
+                    else {
+                        try {
+                            this.allFailed(options, authenticateResult.failResult, req, res);
+                        }
+                        catch (err) {
+                            next(err);
+                            return;
+                        }
+                    }
+                    next();
+                }.bind(this);
+            }
+            else {
+                return async function passportAuthenticate(ctx, next) {
+                    // koa <-> connect compatibility:
+                    const userProperty = this.passport.getUserProperty();
+                    // create mock object for express' req object
+                    const req = (0, request_1.create)(ctx, userProperty);
+                    // init req method
+                    this.attachRequestMethod(req);
+                    // add Promise-based login method
+                    const login = req.login;
+                    ctx.login = ctx.logIn = function (user, options) {
+                        return new Promise((resolve, reject) => {
+                            login.call(req, user, options, err => {
+                                if (err)
+                                    reject(err);
+                                else
+                                    resolve();
+                            });
+                        });
+                    };
+                    // add aliases for passport's request extensions to Koa's context
+                    ctx.logout = ctx.logOut = req.logout.bind(req);
+                    ctx.isAuthenticated = req.isAuthenticated.bind(req);
+                    ctx.isUnauthenticated = req.isUnauthenticated.bind(req);
+                    // merge options with default options
+                    const authOptions = {
+                        ...this.passportConfig,
+                        ...options,
+                    };
+                    const strategyList = [];
+                    for (const strategySingle of strategy) {
+                        // got strategy
+                        const strategyInstance = await this.app
+                            .getApplicationContext()
+                            .getAsync(strategySingle);
+                        strategyList.push(strategyInstance.getStrategy());
+                    }
+                    // authenticate
+                    const authenticate = this.passport.authenticate(strategyList, authOptions);
+                    const authenticateResult = await authenticate(req);
+                    // success
+                    if (authenticateResult.successResult) {
+                        const breakNext = await this.onceSucceed(options, authenticateResult.successResult.user, authenticateResult.successResult.info, req, ctx);
+                        if (breakNext) {
+                            return;
+                        }
+                    }
+                    else if (authenticateResult.redirectResult) {
+                        // redirect
+                        ctx.status = authenticateResult.redirectResult.status || 302;
+                        ctx.set('Location', authenticateResult.redirectResult.url);
+                        ctx.set('Content-Length', '0');
+                        return;
+                    }
+                    else {
+                        this.allFailed(options, authenticateResult.failResult, req, {
+                            end(data) {
+                                ctx.body = data;
+                            },
+                            redirect(url) {
+                                ctx.redirect(url);
+                            },
+                        });
+                        return;
+                    }
+                    await next();
+                }.bind(this);
+            }
+        }
+        static getName() {
+            return 'passport';
+        }
+        async onceSucceed(options, user, info, req, res) {
+            let msg;
+            // if (options.successFlash) {
+            //   let flash: any = options.successFlash;
+            //   if (typeof flash === 'string') {
+            //     flash = { type: 'success', message: flash };
+            //   }
+            //   flash.type = flash.type || 'success';
+            //
+            //   const type = flash.type || info.type || 'success';
+            //   msg = flash.message || info.message || info;
+            //   if (typeof msg === 'string') {
+            //     req.flash && req.flash(type, msg);
+            //   }
+            // }
+            if (options.successMessage) {
+                msg = options.successMessage;
+                if (typeof msg === 'boolean') {
+                    msg = info.message || info;
+                }
+                if (typeof msg === 'string') {
+                    req.session.messages = req.session.messages || [];
+                    req.session.messages.push(msg);
+                }
+            }
+            if (options.assignProperty) {
+                req[options.assignProperty] = user;
+                return;
+            }
+            await req.logIn(user, options);
+            if (options.authInfo !== false) {
+                await new Promise((resolve, reject) => {
+                    this.passport.transformAuthInfo(info, req, (err, tinfo) => {
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            req.authInfo = tinfo;
+                            resolve();
+                        }
+                    });
+                });
+            }
+            if (options.successReturnToOrRedirect) {
+                let url = options.successReturnToOrRedirect;
+                if (req.session && req.session.returnTo) {
+                    url = req.session.returnTo;
+                    delete req.session.returnTo;
+                }
+                res.redirect(url);
+                return true;
+            }
+            if (options.successRedirect) {
+                res.redirect(options.successRedirect);
+                return true;
+            }
+        }
+        allFailed(options, failResult, req, res) {
+            // Strategies are ordered by priority.  For the purpose of flashing a
+            // message, the first failure will be displayed.
+            let failure = failResult.failures[0] || {}, challenge = (failure === null || failure === void 0 ? void 0 : failure.challenge) || {}, msg;
+            // if (options.failureFlash) {
+            //   let flash: any = options.failureFlash;
+            //   if (typeof flash === 'string') {
+            //     flash = { type: 'error', message: flash };
+            //   }
+            //   flash.type = flash.type || 'error';
+            //
+            //   const type = flash.type || challenge.type || 'error';
+            //   msg = flash.message || challenge.message || challenge;
+            //   if (typeof msg === 'string') {
+            //     req.flash && req.flash(type, msg);
+            //   }
+            // }
+            if (options.failureMessage) {
+                msg = options.failureMessage;
+                if (typeof msg === 'boolean') {
+                    msg = challenge.message || challenge;
+                }
+                if (typeof msg === 'string') {
+                    req.session.messages = req.session.messages || [];
+                    req.session.messages.push(msg);
+                }
+            }
+            if (options.failureRedirect) {
+                return res.redirect(options.failureRedirect);
+            }
+            // When failure handling is not delegated to the application, the default
+            // is to respond with 401 Unauthorized.  Note that the WWW-Authenticate
+            // header will be set according to the strategies in use (see
+            // actions#fail).  If multiple strategies failed, each of their challenges
+            // will be included in the response.
+            const rchallenge = [];
+            let rstatus, status;
+            for (let j = 0, len = failResult.failures.length; j < len; j++) {
+                failure = failResult.failures[j];
+                challenge = failure.challenge;
+                status = failure.status;
+                rstatus = rstatus || status;
+                if (typeof challenge === 'string') {
+                    rchallenge.push(challenge);
+                }
+            }
+            res.statusCode = rstatus || 401;
+            // eslint-disable-next-line eqeqeq
+            if (res.statusCode === 401 && rchallenge.length) {
+                res.setHeader('WWW-Authenticate', rchallenge);
+            }
+            // if (options.failWithError) {
+            //   throw new httpError.UnauthorizedError();
+            // }
+            throw new core_1.httpError.UnauthorizedError();
+        }
+        attachRequestMethod(req) {
+            // init req method
+            req.login = req.logIn = (user, options, done) => {
+                if (typeof options === 'function') {
+                    done = options;
+                    options = {};
+                }
+                options = options || {};
+                const property = this.passport.getUserProperty();
+                req[property] = user;
+                if (this.passport.isEnableSession()) {
+                    return this.passport.logInToSession(req, user).catch(err => {
+                        req[property] = null;
+                        if (done) {
+                            done(err);
+                        }
+                        else {
+                            throw err;
+                        }
+                    });
+                }
+                else {
+                    return Promise.resolve().then(() => {
+                        if (done) {
+                            done();
+                        }
+                    });
+                }
+            };
+            req.logout = req.logOut = (options, done) => {
+                if (typeof options === 'function') {
+                    done = options;
+                    options = {};
+                }
+                options = options || {};
+                req[this.passport.getUserProperty()] = null;
+                if (this.passport.isEnableSession()) {
+                    return this.passport.logOutFromSession(req, options).catch(err => {
+                        if (done) {
+                            done(err);
+                        }
+                        else {
+                            throw err;
+                        }
+                    });
+                }
+                else {
+                    return Promise.resolve().then(() => {
+                        if (done) {
+                            done();
+                        }
+                    });
+                }
+            };
+            req.isAuthenticated = () => {
+                const property = this.passport.getUserProperty();
+                return !!this[property];
+            };
+            req.isUnauthenticated = () => {
+                return !req.isAuthenticated();
+            };
+        }
+    }
+    __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);
+    __decorate([
+        (0, decorator_1.Inject)(),
+        __metadata("design:type", authenticator_1.PassportAuthenticator)
+    ], InnerPassportMiddleware.prototype, "passport", void 0);
+    return InnerPassportMiddleware;
+}
+exports.PassportMiddleware = PassportMiddleware;
+//# sourceMappingURL=passport.service.js.map

package/dist/passport/pause.d.ts

@@ -0,0 +1,19 @@
+/*!
+ * pause
+ * Copyright(c) 2012 TJ Holowaychuk
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+/// <reference types="node" />
+import { Stream } from 'stream';
+/**
+ * Pause the data events on a stream.
+ *
+ * @param {object} stream
+ * @public
+ */
+export declare function pause(stream: Stream): {
+    end: () => void;
+    resume: () => void;
+};
+//# sourceMappingURL=pause.d.ts.map

package/dist/passport/pause.js

@@ -0,0 +1,50 @@
+"use strict";
+/*!
+ * pause
+ * Copyright(c) 2012 TJ Holowaychuk
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pause = void 0;
+/**
+ * Pause the data events on a stream.
+ *
+ * @param {object} stream
+ * @public
+ */
+function pause(stream) {
+    const events = [];
+    const onData = createEventListener('data', events);
+    const onEnd = createEventListener('end', events);
+    // buffer data
+    stream.on('data', onData);
+    // buffer end
+    stream.on('end', onEnd);
+    return {
+        end: function end() {
+            stream.removeListener('data', onData);
+            stream.removeListener('end', onEnd);
+        },
+        resume: function resume() {
+            this.end();
+            for (let i = 0; i < events.length; i++) {
+                // eslint-disable-next-line prefer-spread
+                stream.emit.apply(stream, events[i]);
+            }
+        },
+    };
+}
+exports.pause = pause;
+function createEventListener(name, events) {
+    return function onEvent() {
+        const args = new Array(arguments.length + 1);
+        args[0] = name;
+        for (let i = 0; i < arguments.length; i++) {
+            // eslint-disable-next-line prefer-rest-params
+            args[i + 1] = arguments[i];
+        }
+        events.push(args);
+    };
+}
+//# sourceMappingURL=pause.js.map

package/dist/passport/request.d.ts

@@ -0,0 +1,2 @@
+export declare function create(ctx: any, userProperty: any): any;
+//# sourceMappingURL=request.d.ts.map

package/dist/{proxy/framework → passport}/request.js

@@ -1,4 +1,7 @@
+"use strict";
 /* eslint-disable */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
 // Koa and Express are fundamental different in how they deal with extensions
 // to the incoming request.
 // Express pollutes Node's IncomingRequest directly, while Koa keeps Node's
@@ -116,31 +119,20 @@ function getObject(ctx, key) {
     }
     return undefined;
 }
-const IncomingMessageExt = require('passport/lib/http/request');
-exports.create = function (ctx, userProperty) {
+function create(ctx, userProperty) {
     const req = Object.create(ctx.request, properties);
-    Object.defineProperty(req, userProperty, {
-        enumerable: true,
-        get: function () {
-            return ctx.state[userProperty];
-        },
-        set: function (val) {
-            ctx.state[userProperty] = val;
-        },
-    });
-    Object.defineProperty(req, 'ctx', {
-        enumerable: true,
-        get: function () {
-            return ctx;
-        },
-    });
-    // add passport http.IncomingMessage extensions
-    req.login = IncomingMessageExt.logIn;
-    req.logIn = IncomingMessageExt.logIn;
-    req.logout = IncomingMessageExt.logOut;
-    req.logOut = IncomingMessageExt.logOut;
-    req.isAuthenticated = IncomingMessageExt.isAuthenticated;
-    req.isUnauthenticated = IncomingMessageExt.isUnauthenticated;
+    if (!ctx.state.hasOwnProperty(userProperty)) {
+        Object.defineProperty(ctx.state, userProperty, {
+            enumerable: true,
+            get: function () {
+                return req[userProperty];
+            },
+            set: function (val) {
+                req[userProperty] = val;
+            },
+        });
+    }
     return req;
-};
+}
+exports.create = create;
 //# sourceMappingURL=request.js.map

package/dist/passport/session.stratey.d.ts

@@ -0,0 +1,34 @@
+import { Strategy } from './strategy';
+/**
+ * `SessionStrategy` constructor.
+ *
+ * @api public
+ */
+export declare class SessionStrategy extends Strategy {
+    readonly options: {
+        userProperty: string;
+        sessionUserProperty: string;
+        pauseStream?: boolean;
+    };
+    _deserializeUser: any;
+    constructor(options: {
+        userProperty: string;
+        sessionUserProperty: string;
+        pauseStream?: boolean;
+    }, deserializeUser: any);
+    /**
+     * Authenticate request based on the current session state.
+     *
+     * The session authentication strategy uses the session to restore any login
+     * state across requests.  If a login session has been established, `req.user`
+     * will be populated with the current user.
+     *
+     * This strategy is registered automatically by Passport.
+     *
+     * @param {Object} req
+     * @param {Object} options
+     * @api protected
+     */
+    authenticate(req: any, options: any): import("@midwayjs/core/dist/error/http").UnauthorizedError;
+}
+//# sourceMappingURL=session.stratey.d.ts.map

package/dist/passport/session.stratey.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionStrategy = void 0;
+const strategy_1 = require("./strategy");
+const core_1 = require("@midwayjs/core");
+const pause_1 = require("./pause");
+/**
+ * `SessionStrategy` constructor.
+ *
+ * @api public
+ */
+class SessionStrategy extends strategy_1.Strategy {
+    constructor(options, deserializeUser) {
+        super();
+        this.options = options;
+        this.name = 'session';
+        this._deserializeUser = deserializeUser;
+    }
+    /**
+     * Authenticate request based on the current session state.
+     *
+     * The session authentication strategy uses the session to restore any login
+     * state across requests.  If a login session has been established, `req.user`
+     * will be populated with the current user.
+     *
+     * This strategy is registered automatically by Passport.
+     *
+     * @param {Object} req
+     * @param {Object} options
+     * @api protected
+     */
+    authenticate(req, options) {
+        if (!req.session) {
+            return new core_1.httpError.UnauthorizedError('Login sessions require session support，please enable it.');
+        }
+        options = options || {};
+        let su;
+        if (req.session[this.options.sessionUserProperty]) {
+            su = req.session[this.options.sessionUserProperty].user;
+        }
+        if (su || su === 0) {
+            // NOTE: Stream pausing is desirable in the case where later middleware is
+            //       listening for events emitted from request.  For discussion on the
+            //       matter, refer to: https://github.com/jaredhanson/passport/pull/106
+            const paused = options.pauseStream ? (0, pause_1.pause)(req) : null;
+            this._deserializeUser(su, req, (err, user) => {
+                if (err) {
+                    return new core_1.httpError.UnauthorizedError(err.message);
+                }
+                if (!user) {
+                    delete req.session[this.options.sessionUserProperty].user;
+                    this.pass();
+                }
+                else {
+                    this.success(user);
+                }
+                if (paused) {
+                    paused.resume();
+                }
+            });
+        }
+        else {
+            this.pass();
+        }
+    }
+}
+exports.SessionStrategy = SessionStrategy;
+//# sourceMappingURL=session.stratey.js.map

package/dist/passport/strategy.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import { IncomingMessage } from 'http';
+import { IPassportStrategy, StrategyCreatedStatic } from '../interface';
+export declare abstract class Strategy {
+    name?: string | undefined;
+    abstract authenticate(req: IncomingMessage, options?: any): any;
+}
+export interface Strategy extends StrategyCreatedStatic {
+}
+export declare abstract class AbstractStrategyWrapper implements IPassportStrategy {
+    abstract validate(...args: any[]): any;
+    abstract getStrategyOptions(): any;
+}
+//# sourceMappingURL=strategy.d.ts.map

package/dist/passport/strategy.js

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

package/index.d.ts

@@ -1,10 +1,10 @@
-import * as passport from 'passport';
+import { AuthenticateOptions } from './dist/index';
 
 export * from './dist/index';
 
 declare module '@midwayjs/core/dist/interface' {
   interface MidwayConfig {
-    passport?: passport.AuthenticateOptions;
+    passport?: AuthenticateOptions;
   }
 }