@midwayjs/passport 3.4.0-beta.1 → 3.4.0-beta.12

package/dist/service/passport.service.d.ts

@@ -1,6 +0,0 @@
-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(strategy: StrategyClass | StrategyClass[]): new (...args: any[]) => AbstractPassportMiddleware;
-//# sourceMappingURL=passport.service.d.ts.map

package/dist/service/passport.service.js

@@ -1,226 +0,0 @@
-"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 util_1 = require("../util");
-const interface_1 = require("../interface");
-const core_1 = require("@midwayjs/core");
-function PassportStrategy(Strategy, name) {
-    class InnerStrategyAbstractClass extends interface_1.AbstractStrategy {
-        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);
-            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(strategy) {
-    class InnerPassportMiddleware extends interface_1.AbstractPassportMiddleware {
-        resolve() {
-            if ((0, util_1.isExpressMode)()) {
-                return async function passportMiddleware(req, res, next) {
-                    return this.authenticate(await this.getAuthenticateOptions())(req, res, next);
-                }.bind(this);
-            }
-            else {
-                return async function passportMiddleware(ctx, next) {
-                    return this.authenticate(await this.getAuthenticateOptions())(ctx, next);
-                }.bind(this);
-            }
-        }
-        getAuthenticateOptions() {
-            return undefined;
-        }
-        authenticate(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.userProperty]) {
-                        req[authOptions.userProperty] =
-                            req.session[authOptions.userProperty];
-                    }
-                    // ignore user has exists
-                    if (req[authOptions.userProperty]) {
-                        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);
-                            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.userProperty] = user;
-                            if (authOptions.session) {
-                                req.logIn(user, options, next);
-                                return;
-                            }
-                        }
-                        else {
-                            if (options.failureRedirect) {
-                                res.redirect(options.failureRedirect);
-                                return;
-                            }
-                            else {
-                                throw new core_1.httpError.UnauthorizedError();
-                            }
-                        }
-                        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();
-                    }
-                    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 {
-                                    throw new core_1.httpError.UnauthorizedError();
-                                }
-                            }
-                            await next();
-                        }
-                        catch (err) {
-                            ctx.throw(err);
-                        }
-                    }
-                }.bind(this);
-            }
-        }
-        static getName() {
-            return 'passport';
-        }
-    }
-    __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.service.js.map

package/dist/util.d.ts

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

package/dist/util.js

@@ -1,16 +0,0 @@
-"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').passport;
-}
-exports.getPassport = getPassport;
-function isExpressMode() {
-    return !!(process.env['MIDWAY_PASSPORT_MODE'] === 'express' ||
-        (0, core_1.safeRequire)('@midwayjs/express'));
-}
-exports.isExpressMode = isExpressMode;
-//# sourceMappingURL=util.js.map