@midwayjs/passport 2.14.0 → 2.14.1

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 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)
+
+
+### Bug Fixes
+
+* passport missing proxy file ([#1405](https://github.com/midwayjs/midway/issues/1405)) ([ded726a](https://github.com/midwayjs/midway/commit/ded726aeda756aea4dcb2c616d3bc85984e46a60))
+
+
+
+
+
 # [2.14.0](https://github.com/midwayjs/midway/compare/v2.13.5...v2.14.0) (2021-12-06)
 
 

package/dist/proxy/framework/koa.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Module dependencies.
+ */
+declare const passport: any;
+/**
+ * Passport's default/connect middleware.
+ */
+declare const _initialize: any;
+declare const _authenticate: any;
+declare const createReqMock: any;
+/**
+ * Passport's initialization middleware for Koa.
+ *
+ * @return {GeneratorFunction}
+ * @api private
+ */
+declare function initialize(passport: any): (ctx: any, next: any) => Promise<any>;
+/**
+ * Passport's authenticate middleware for Koa.
+ *
+ * @param {String|Array} name
+ * @param {Object} options
+ * @param {GeneratorFunction} callback
+ * @return {GeneratorFunction}
+ * @api private
+ */
+declare function authenticate(passport: any, name: any, options: any, callback: any): (ctx: any, next: any) => Promise<any>;
+/**
+ * Passport's authorize middleware for Koa.
+ *
+ * @param {String|Array} name
+ * @param {Object} options
+ * @param {GeneratorFunction} callback
+ * @return {GeneratorFunction}
+ * @api private
+ */
+declare function authorize(passport: any, name: any, options: any, callback: any): (ctx: any, next: any) => Promise<any>;
+declare function promisify(expressMiddleware: any): (req: any, res: any) => Promise<unknown>;
+//# sourceMappingURL=koa.d.ts.map

package/dist/proxy/framework/koa.js

@@ -0,0 +1,186 @@
+'use strict';
+/**
+ * Module dependencies.
+ */
+const passport = require('passport');
+/**
+ * Passport's default/connect middleware.
+ */
+const _initialize = require('passport/lib/middleware/initialize');
+const _authenticate = require('passport/lib/middleware/authenticate');
+const createReqMock = require('./request').create;
+/**
+ * Passport's initialization middleware for Koa.
+ *
+ * @return {GeneratorFunction}
+ * @api private
+ */
+function initialize(passport) {
+    const middleware = promisify(_initialize(passport));
+    return function passportInitialize(ctx, next) {
+        // koa <-> connect compatibility:
+        const userProperty = passport._userProperty || 'user';
+        // check ctx.req has the userProperty
+        // eslint-disable-next-line no-prototype-builtins
+        if (!ctx.req.hasOwnProperty(userProperty)) {
+            Object.defineProperty(ctx.req, userProperty, {
+                enumerable: true,
+                get: function () {
+                    return ctx.state[userProperty];
+                },
+                set: function (val) {
+                    ctx.state[userProperty] = val;
+                },
+            });
+        }
+        // create mock object for express' req object
+        const req = createReqMock(ctx, userProperty);
+        // 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);
+        return middleware(req, ctx).then(() => {
+            return next();
+        });
+    };
+}
+/**
+ * Passport's authenticate middleware for Koa.
+ *
+ * @param {String|Array} name
+ * @param {Object} options
+ * @param {GeneratorFunction} callback
+ * @return {GeneratorFunction}
+ * @api private
+ */
+function authenticate(passport, name, options, callback) {
+    // normalize arguments
+    if (typeof options === 'function') {
+        callback = options;
+        options = {};
+    }
+    options = options || {};
+    if (callback) {
+        // When the callback is set, neither `next`, `res.redirect` or `res.end`
+        // are called. That is, a workaround to catch the `callback` is required.
+        // The `passportAuthenticate()` method below will therefore set
+        // `callback.resolve` and `callback.reject`. Then, once the authentication
+        // finishes, the modified callback calls the original one and afterwards
+        // triggers either `callback.resolve` or `callback.reject` to inform
+        // `passportAuthenticate()` that we are ready.
+        const _callback = callback;
+        callback = function (err, user, info, status) {
+            try {
+                Promise.resolve(_callback(err, user, info, status))
+                    .then(() => callback.resolve(false))
+                    .catch(err => callback.reject(err));
+            }
+            catch (err) {
+                callback.reject(err);
+            }
+        };
+    }
+    const middleware = promisify(_authenticate(passport, name, options, callback));
+    return function passportAuthenticate(ctx, next) {
+        // this functions wraps the connect middleware
+        // to catch `next`, `res.redirect` and `res.end` calls
+        const p = new Promise((resolve, reject) => {
+            // mock the `req` object
+            const req = createReqMock(ctx, options.assignProperty || passport._userProperty || 'user');
+            function setBodyAndResolve(content) {
+                if (content)
+                    ctx.body = content;
+                resolve(false);
+            }
+            // mock the `res` object
+            const res = {
+                redirect: function (url) {
+                    ctx.redirect(url);
+                    resolve(false);
+                },
+                set: ctx.set.bind(ctx),
+                setHeader: ctx.set.bind(ctx),
+                end: setBodyAndResolve,
+                send: setBodyAndResolve,
+                set statusCode(status) {
+                    ctx.status = status;
+                },
+                get statusCode() {
+                    return ctx.status;
+                },
+            };
+            req.res = res;
+            // update the custom callback above
+            if (callback) {
+                callback.resolve = resolve;
+                callback.reject = reject;
+            }
+            // call the connect middleware
+            middleware(req, res).then(resolve, reject);
+        });
+        return p.then(cont => {
+            // cont equals `false` when `res.redirect` or `res.end` got called
+            // in this case, call next to continue through Koa's middleware stack
+            if (cont !== false) {
+                return next();
+            }
+        });
+    };
+}
+/**
+ * Passport's authorize middleware for Koa.
+ *
+ * @param {String|Array} name
+ * @param {Object} options
+ * @param {GeneratorFunction} callback
+ * @return {GeneratorFunction}
+ * @api private
+ */
+function authorize(passport, name, options, callback) {
+    options = options || {};
+    options.assignProperty = 'account';
+    return authenticate(passport, name, options, callback);
+}
+/**
+ * Framework support for Koa.
+ *
+ * This module provides support for using Passport with Koa. It exposes
+ * middleware that conform to the `fn*(next)` signature and extends
+ * Node's built-in HTTP request object with useful authentication-related
+ * functions.
+ *
+ * @return {Object}
+ * @api protected
+ */
+module.exports = function () {
+    return {
+        initialize: initialize,
+        authenticate: authenticate,
+        authorize: authorize,
+    };
+};
+function promisify(expressMiddleware) {
+    return function (req, res) {
+        return new Promise((resolve, reject) => {
+            expressMiddleware(req, res, (err, result) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(result);
+            });
+        });
+    };
+}
+//# sourceMappingURL=koa.js.map

package/dist/proxy/framework/request.d.ts

@@ -0,0 +1,11 @@
+declare let keys: string[];
+declare const properties: {
+    app: {
+        get: () => {
+            get: (key: any) => any;
+        };
+    };
+};
+declare function getObject(ctx: any, key: any): any;
+declare const IncomingMessageExt: any;
+//# sourceMappingURL=request.d.ts.map

package/dist/proxy/framework/request.js

@@ -0,0 +1,146 @@
+/* eslint-disable */
+// 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
+// IncomingRequest untouched and adds is own high-level request object.
+// These both approaches are not directly compatible with each other, since
+// properties/methods found in Express' `req` object are now spread between
+// Koa's context, Koa's request object and the original incoming request.
+// This makes moking the Express `req` object an ugly task. With ES6 we could
+// simply use a Proxy, e.g.:
+//
+// function createReqMock(ctx) {
+//   // Use a proxy that forwards `req` reads to either `ctx.passport`,
+//   // Node's request, Koa's request or Koa's context. Writes are persistet
+//   // into `ctx.passport`.
+//   return Proxy.create(handler(ctx.passport, {
+//     get: function(receiver, key) {
+//       return ctx.passport[key] || ctx.req[key] || ctx.request[key] || ctx[key]
+//     }
+//   }))
+// }
+//
+// However, the current Proxy implementation does not allow debugging.
+// See: https://github.com/rkusa/koa-passport/issues/17
+//
+// Until this is fixed, koa-passport tries to properly delegate every possible
+// used property/method.
+// Property/Method names to be delegated
+let keys = [
+    // passport
+    '_passport',
+    'authInfo',
+    // http.IncomingMessage
+    'httpVersion',
+    'headers',
+    'trailers',
+    'setTimeout',
+    'method',
+    'url',
+    'statusCode',
+    'socket',
+    'connection',
+    'protocol',
+    // Koa's context
+    'cookies',
+    'throw',
+    'ip',
+    // Others. Are not supported directly - require proper plugins/middlewares.
+    'param',
+    'params',
+    'route',
+    'xhr',
+    'baseUrl',
+    'session',
+    'body',
+    'flash',
+];
+// remove duplicates
+keys = keys.filter((key, i, self) => {
+    return self.indexOf(key) === i;
+});
+// create a delegate for each key
+const properties = {
+    // mock express' .get('trust proxy')
+    app: {
+        // getter returning a mock for `req.app` containing
+        // the `.get()` method
+        get: function () {
+            const ctx = this.ctx;
+            return {
+                get: function (key) {
+                    if (key === 'trust proxy') {
+                        return ctx.app.proxy;
+                    }
+                    return undefined;
+                },
+            };
+        },
+    },
+};
+keys.forEach(key => {
+    properties[key] = {
+        get: function () {
+            const obj = getObject(this.ctx, key);
+            if (!obj)
+                return undefined;
+            // if its a function, call with the proper context
+            if (typeof obj[key] === 'function') {
+                return function () {
+                    return obj[key].apply(obj, arguments);
+                };
+            }
+            // otherwise, simply return it
+            return obj[key];
+        },
+        set: function (value) {
+            const obj = getObject(this.ctx, key) || this.ctx.state;
+            obj[key] = value;
+        },
+    };
+});
+// test where the key is available, either in `ctx.state`, Node's request,
+// Koa's request or Koa's context
+function getObject(ctx, key) {
+    if (ctx.state && key in ctx.state) {
+        return ctx.state;
+    }
+    if (key in ctx.request) {
+        return ctx.request;
+    }
+    if (key in ctx.req) {
+        return ctx.req;
+    }
+    if (key in ctx) {
+        return ctx;
+    }
+    return undefined;
+}
+const IncomingMessageExt = require('passport/lib/http/request');
+exports.create = function (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;
+    return req;
+};
+//# sourceMappingURL=request.js.map

package/dist/proxy/index.d.ts

@@ -0,0 +1,7 @@
+declare const Passport: any;
+export declare class KoaPassport extends Passport {
+    constructor();
+}
+export declare const passport: any;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/proxy/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.passport = exports.KoaPassport = void 0;
+// prevent passport from monkey patching
+const connect = require('passport/lib/framework/connect');
+connect.__monkeypatchNode = function () { };
+// load passport and add the koa framework
+const originPassport = require('passport');
+const Passport = require('passport').Passport;
+const framework = require('./framework/koa')();
+originPassport.framework(framework);
+class KoaPassport extends Passport {
+    constructor() {
+        super();
+        this.framework(framework);
+    }
+}
+exports.KoaPassport = KoaPassport;
+// Export default singleton.
+exports.passport = originPassport;
+//# sourceMappingURL=index.js.map

package/dist/util.js

@@ -3,7 +3,9 @@ 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');
+    return isExpressMode()
+        ? require('passport')
+        : require('./proxy/index').passport;
 }
 exports.getPassport = getPassport;
 function isExpressMode() {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@midwayjs/passport",
   "description": "midway passport component",
-  "version": "2.14.0",
+  "version": "2.14.1",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "files": [
@@ -37,5 +37,5 @@
   "peerDependencies": {
     "passport": "^0.5.0"
   },
-  "gitHead": "5fd716b0e731162d8e9f0931790fde7402fb83de"
+  "gitHead": "b3dc5e27f4d611880e9525a3b798b99b349c3dd5"
 }