Working version

dist/index.js

@@ -3,121 +3,93 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.isTokenExpired = exports.GSCAuthConsumer = exports.GSCAuthProvider = void 0;
+exports.default = void 0;
 
 var _react = _interopRequireDefault(require("react"));
 
-var _reactAadMsal = require("react-aad-msal");
-
-var _jwtDecode = _interopRequireDefault(require("jwt-decode"));
+var _msalB2cReact = _interopRequireDefault(require("@kdpw/msal-b2c-react"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-var isTokenExpired = function isTokenExpired(token) {
+var tokenIsExpired = function tokenIsExpired(decodedToken) {
   try {
-    var decoded = (0, _jwtDecode.default)(token);
-
-    if (decoded.exp < Date.now() / 1000) {
+    if (decodedToken.exp < Date.now() / 1000) {
       return true;
     } else return false;
   } catch (err) {
-    return false;
+    console.error(err);
+    return true;
   }
 };
 
-exports.isTokenExpired = isTokenExpired;
-var emptyAuthObject = {
-  userInfo: {
-    jwtAccessToken: "",
-    jwtIdToken: "",
-    user: {}
-  },
-  login: function login() {},
-  logout: function logout() {}
+var hasValidLogin = function hasValidLogin(authValues) {
+  var token = authValues.idToken;
+  return token && !tokenIsExpired(token);
 };
 
-var GSCAuthContext = _react.default.createContext(emptyAuthObject);
-
-var GSCAuthConsumer = GSCAuthContext.Consumer;
-exports.GSCAuthConsumer = GSCAuthConsumer;
+var runGSCAuth = _msalB2cReact.default.run;
+var requireGSCAuth = _msalB2cReact.default.required;
 
-var GSCAuthProvider =
-/*#__PURE__*/
-function (_React$Component) {
-  _inherits(GSCAuthProvider, _React$Component);
-
-  function GSCAuthProvider() {
-    var _this;
+var getAuthValues = function getAuthValues() {
+  return {
+    userName: _msalB2cReact.default.getUserName(),
+    idToken: _msalB2cReact.default.getIdToken(),
+    accessToken: _msalB2cReact.default.getAccessToken()
+  };
+};
 
-    _classCallCheck(this, GSCAuthProvider);
+var initGSCAuth = function initGSCAuth(applicationId, redirectUri, scopes, cacheLocation) {
+  if (!applicationId) throw new Error("GSCAuth must be provided with an Azure AD application UUID");
+  if (!redirectUri) throw new Error("GSCAuth must be provided with a redirect URI, as configured in the Azure AD portal");
+
+  _msalB2cReact.default.initialize({
+    instance: "https://login.microsoftonline.com/",
+    tenant: "f62a415a-76c0-4075-9eb3-f31250de2db2",
+    signInPolicy: "",
+    resetPolicy: "",
+    applicationId: applicationId,
+    cacheLocation: cacheLocation,
+    scopes: scopes,
+    redirectUri: redirectUri,
+    postLogoutRedirectUri: "https://www.glasgowsciencecentre.org",
+    validateAuthority: true
+  });
 
-    _this = _possibleConstructorReturn(this, _getPrototypeOf(GSCAuthProvider).call(this, props));
-    _this.state = emptyAuthObject;
-    _this.loginCallback = _this.loginCallback.bind(_assertThisInitialized(_assertThisInitialized(_this)));
-    _this.logoutCallback = _this.logoutCallback.bind(_assertThisInitialized(_assertThisInitialized(_this)));
-    _this.userInfoCallback = _this.userInfoCallback.bind(_assertThisInitialized(_assertThisInitialized(_this)));
-    return _this;
-  }
+  var GSCAuthContext = _react.default.createContext(getAuthValues());
 
-  _createClass(GSCAuthProvider, [{
-    key: "loginCallback",
-    value: function loginCallback(login) {
-      this.setState({
-        login: login
-      });
-    }
-  }, {
-    key: "logoutCallback",
-    value: function logoutCallback(logout) {
-      this.setState({
-        logout: logout
-      });
-    }
-  }, {
-    key: "userInfoCallback",
-    value: function userInfoCallback(userInfo) {
-      this.setState({
-        userInfo: userInfo
-      });
-    }
-  }, {
-    key: "render",
-    value: function render() {
-      return _react.default.createElement(_reactAadMsal.AzureAD, {
-        provider: new _reactAadMsal.MsalAuthProviderFactory({
-          clientID: this.props.appId,
-          scopes: this.props.scopes || [],
-          type: _reactAadMsal.LoginType[this.props.loginType || "Redirect"],
-          persistLoginPastSession: this.props.persistLoginPastSession || false
-        }),
-        unauthenticatedFunction: this.loginCallback,
-        authenticatedFunction: this.logoutCallback,
-        userInfoCallback: this.userInfoCallback
-      }, _react.default.createElement(GSCAuthContext.Provider, {
-        value: this.state
-      }, this.props.children));
-    }
-  }]);
+  var GSCAuthProvider = GSCAuthContext.Provider;
+  var GSCAuthConsumer = GSCAuthContext.Consumer;
+  return {
+    GSCAuthProvider: GSCAuthProvider,
+    GSCAuthConsumer: GSCAuthConsumer
+  };
+};
 
-  return GSCAuthProvider;
-}(_react.default.Component);
+var setupGSCAuth = function setupGSCAuth(aadAppId, authRedirectUri) {
+  var msGraphScopes = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ["User.Read"];
+  var cacheLocation = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : "sessionStorage";
+
+  var _initGSCAuth = initGSCAuth(aadAppId, authRedirectUri, msGraphScopes, cacheLocation),
+      GSCAuthProvider = _initGSCAuth.GSCAuthProvider,
+      GSCAuthConsumer = _initGSCAuth.GSCAuthConsumer;
+
+  var initialAuthValues = getAuthValues();
+
+  var clearGSCAuth = function clearGSCAuth() {
+    return window[cacheLocation].clear();
+  };
+
+  return {
+    GSCAuthProvider: GSCAuthProvider,
+    GSCAuthConsumer: GSCAuthConsumer,
+    initialAuthValues: initialAuthValues,
+    getAuthValues: getAuthValues,
+    hasValidLogin: hasValidLogin,
+    runGSCAuth: runGSCAuth,
+    requireGSCAuth: requireGSCAuth,
+    clearGSCAuth: clearGSCAuth
+  };
+};
 
-exports.GSCAuthProvider = GSCAuthProvider;
+var _default = setupGSCAuth;
\ No newline at end of file
+exports.default = _default;
\ No newline at end of file

package.json

@@ -11,14 +11,10 @@
     },
     "dependencies": {
         "@babel/polyfill": "^7.2.5",
-        "jwt-decode": "^2.2.0",
-        "react-aad-msal": "^0.4.1"
-    },
-    "resolutions": {
-        "react-aad-msal/babel-jest": ">=23.6.0"
+        "@kdpw/msal-b2c-react": "^0.0.2"
     },
     "peerDependencies": {
-        "react": "^16.7.0"
+        "react": ">=16.8.0"
     },
     "devDependencies": {
         "@babel/cli": "^7.2.3",

src/index.js

 import React from "react";
-import { AzureAD, MsalAuthProviderFactory, LoginType } from "react-aad-msal";
-import decode from "jwt-decode";
+import authentication from "@kdpw/msal-b2c-react";
 
-const isTokenExpired = token => {
+const tokenIsExpired = decodedToken => {
     try {
-        const decoded = decode(token);
-        if (decoded.exp < Date.now() / 1000) {
+        if (decodedToken.exp < Date.now() / 1000) {
             return true;
         } else return false;
     } catch (err) {
-        return false;
+        console.error(err);
+        return true;
     }
 };
 
-const emptyAuthObject = {
-    userInfo: {
-        jwtAccessToken: "",
-        jwtIdToken: "",
-        user: {},
-    },
-    login: () => {},
-    logout: () => {},
+const hasValidLogin = authValues => {
+    const token = authValues.idToken;
+    return token && !tokenIsExpired(token);
 };
 
-const GSCAuthContext = React.createContext(emptyAuthObject);
+const runGSCAuth = authentication.run;
 
-const GSCAuthConsumer = GSCAuthContext.Consumer;
+const requireGSCAuth = authentication.required;
 
-class GSCAuthProvider extends React.Component {
-    constructor() {
-        super(props);
-        this.state = emptyAuthObject;
+const getAuthValues = () => ({
+    userName: authentication.getUserName(),
+    idToken: authentication.getIdToken(),
+    accessToken: authentication.getAccessToken(),
+});
 
-        this.loginCallback = this.loginCallback.bind(this);
-        this.logoutCallback = this.logoutCallback.bind(this);
-        this.userInfoCallback = this.userInfoCallback.bind(this);
-    }
+const initGSCAuth = (applicationId, redirectUri, scopes, cacheLocation) => {
+    if (!applicationId) throw new Error("GSCAuth must be provided with an Azure AD application UUID");
+    if (!redirectUri)
+        throw new Error("GSCAuth must be provided with a redirect URI, as configured in the Azure AD portal");
+    authentication.initialize({
+        instance: "https://login.microsoftonline.com/",
+        tenant: "f62a415a-76c0-4075-9eb3-f31250de2db2",
+        signInPolicy: "",
+        resetPolicy: "",
+        applicationId,
+        cacheLocation,
+        scopes,
+        redirectUri,
+        postLogoutRedirectUri: "https://www.glasgowsciencecentre.org",
+        validateAuthority: true,
+    });
 
-    loginCallback(login) {
-        this.setState({ login });
-    }
+    const GSCAuthContext = React.createContext(getAuthValues());
+    const GSCAuthProvider = GSCAuthContext.Provider;
+    const GSCAuthConsumer = GSCAuthContext.Consumer;
 
-    logoutCallback(logout) {
-        this.setState({ logout });
-    }
+    return { GSCAuthProvider, GSCAuthConsumer };
+};
 
-    userInfoCallback(userInfo) {
-        this.setState({ userInfo });
-    }
+const setupGSCAuth = (aadAppId, authRedirectUri, msGraphScopes = ["User.Read"], cacheLocation = "sessionStorage") => {
+    const { GSCAuthProvider, GSCAuthConsumer } = initGSCAuth(aadAppId, authRedirectUri, msGraphScopes, cacheLocation);
+    const initialAuthValues = getAuthValues();
+    const clearGSCAuth = () => window[cacheLocation].clear();
 
-    render() {
-        return (
-            <AzureAD
-                provider={
-                    new MsalAuthProviderFactory({
-                        clientID: this.props.appId,
-                        scopes: this.props.scopes || [],
-                        type: LoginType[this.props.loginType || "Redirect"],
-                        persistLoginPastSession: this.props.persistLoginPastSession || false,
-                    })
-                }
-                unauthenticatedFunction={this.loginCallback}
-                authenticatedFunction={this.logoutCallback}
-                userInfoCallback={this.userInfoCallback}
-            >
-                <GSCAuthContext.Provider value={this.state}>{this.props.children}</GSCAuthContext.Provider>
-            </AzureAD>
-        );
-    }
-}
+    return {
+        GSCAuthProvider,
+        GSCAuthConsumer,
+        initialAuthValues,
+        getAuthValues,
+        hasValidLogin,
+        runGSCAuth,
+        requireGSCAuth,
+        clearGSCAuth,
+    };
+};
 
-export { GSCAuthProvider, GSCAuthConsumer, isTokenExpired };
+export default setupGSCAuth;