propro-utils 1.3.13 → 1.3.15

package/dist/NotifLocal.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var React = require("react");
+var _require = require("@react-email/components"),
+  Button = _require.Button,
+  Container = _require.Container,
+  Head = _require.Head,
+  Html = _require.Html,
+  Img = _require.Img,
+  Section = _require.Section,
+  Text = _require.Text;
+var NotifLocal = function NotifLocal(_ref) {
+  var body = _ref.body,
+    app = _ref.app,
+    label = _ref.label,
+    url = _ref.url;
+  var getLogoUrl = function getLogoUrl(app) {
+    switch (app) {
+      case "hubhub":
+        return "/assets/logos/hubhub.svg";
+      case "propro":
+        return "/assets/logos/propro.svg";
+      default:
+        return "/assets/logos/hubhub.svg";
+    }
+  };
+  return /*#__PURE__*/React.createElement(Html, null, /*#__PURE__*/React.createElement(Head, null), /*#__PURE__*/React.createElement(Section, {
+    style: main
+  }, /*#__PURE__*/React.createElement(Container, {
+    style: container
+  }, /*#__PURE__*/React.createElement(Img, {
+    src: getLogoUrl(app)
+  }), /*#__PURE__*/React.createElement(Section, null, /*#__PURE__*/React.createElement(Text, {
+    style: text
+  }, body || "Default body text here."), label && /*#__PURE__*/React.createElement(Button, {
+    href: url,
+    style: btn
+  }, label)))));
+};
+var main = {
+  backgroundColor: "#ffffff",
+  margin: "0 auto"
+};
+var container = {
+  border: "1px solid #eaeaea",
+  borderRadius: "5px",
+  margin: "40px auto",
+  padding: "20px",
+  width: "465px"
+};
+var h1 = {
+  color: "#000",
+  fontFamily: "-apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue', sans-serif",
+  fontSize: "24px",
+  fontWeight: "normal",
+  textAlign: "center",
+  margin: "30px 0",
+  padding: "0"
+};
+var text = {
+  color: "#000",
+  fontFamily: "-apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue', sans-serif",
+  fontSize: "14px",
+  lineHeight: "24px"
+};
+var btn = {
+  backgroundColor: "#000",
+  borderRadius: "5px",
+  color: "#fff",
+  fontFamily: "-apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue', sans-serif",
+  fontSize: "12px",
+  fontWeight: 500,
+  lineHeight: "50px",
+  textDecoration: "none",
+  textAlign: "center"
+};
+var _default = exports["default"] = NotifLocal;

package/dist/emailStrategy.js

@@ -9,62 +9,87 @@ function _defineProperties(target, props) { for (var i = 0; i < props.length; i+
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
 function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-// EmailNotificationStrategy.js
+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 } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+require("dotenv").config();
 var React = require("react");
 var ReactDOMServer = require("react-dom/server");
 var NotifLocal = require("./NotifLocal");
 var nodemailer = require("nodemailer");
 var mailgun = require("nodemailer-mailgun-transport");
-var templateData = require("./template.data");
+var _require = require("./template.data"),
+  templateData = _require.templateData;
+var _require2 = require("./baseStrategy"),
+  NotificationStrategy = _require2.NotificationStrategy;
+var mailgunTransport = nodemailer.createTransport(mailgun({
+  host: process.env.SMTP_HOST,
+  auth: {
+    api_key: process.env.MAILGUN_API_KEY,
+    domain: process.env.EMAIL_DOMAIN
+  }
+}));
 
 /**
  * Represents a strategy for sending email notifications.
  */
-var EmailNotificationStrategy = /*#__PURE__*/function () {
+var EmailNotificationStrategy = /*#__PURE__*/function (_NotificationStrategy) {
+  _inherits(EmailNotificationStrategy, _NotificationStrategy);
+  var _super = _createSuper(EmailNotificationStrategy);
   function EmailNotificationStrategy() {
     _classCallCheck(this, EmailNotificationStrategy);
-    this.mailgunTransport = nodemailer.createTransport(mailgun({
-      host: process.env.SMTP_HOST,
-      auth: {
-        // api_key: process.env.MAILGUN_API_KEY,
-        api_key: "3aa03bb5e30f28345ff12a46c7977b20-e438c741-e3e2e5ab",
-        domain: process.env.EMAIL_DOMAIN
-      }
-    }));
+    return _super.apply(this, arguments);
   }
   _createClass(EmailNotificationStrategy, [{
     key: "sendNotification",
     value: function () {
       var _sendNotification = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(to, templateName, templateArgs) {
-        var selectedTemplate, emailHTML, message, info;
+        var templates, selectedTemplate, emailHTML, message, info;
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
-              selectedTemplate = templateData[templateName];
-              emailHTML = ReactDOMServer.renderToString(React.createElement(NotifLocal, selectedTemplate));
+              templates = templateData(templateArgs || {});
+              selectedTemplate = templates[templateName];
+              if (selectedTemplate) {
+                _context.next = 4;
+                break;
+              }
+              throw new Error("Template '".concat(templateName, "' not found"));
+            case 4:
+              console.log("selectedTemplate", selectedTemplate);
+              console.log("templateData", templateData);
+              // const emailHTML = ReactDOMServer.renderToString(
+              //   React.createElement(NotifLocal, selectedTemplate)
+              // );
+              emailHTML = "<h1>".concat(selectedTemplate.body, "</h1>");
               message = {
                 from: process.env.EMAIL_FROM,
                 to: to,
-                subject: selectedTemplate.subject,
+                subject: selectedTemplate.subject || "New Notification",
                 html: emailHTML
               };
-              _context.prev = 3;
-              _context.next = 6;
-              return this.mailgunTransport.sendMail(message);
-            case 6:
+              _context.prev = 8;
+              console.log("Email Message Object:", message);
+              _context.next = 12;
+              return mailgunTransport.sendMail(message);
+            case 12:
               info = _context.sent;
               console.log("Message sent: %s", info.messageId);
-              _context.next = 13;
+              _context.next = 19;
               break;
-            case 10:
-              _context.prev = 10;
-              _context.t0 = _context["catch"](3);
+            case 16:
+              _context.prev = 16;
+              _context.t0 = _context["catch"](8);
               console.error("Error sending email", _context.t0);
-            case 13:
+            case 19:
             case "end":
               return _context.stop();
           }
-        }, _callee, this, [[3, 10]]);
+        }, _callee, null, [[8, 16]]);
       }));
       function sendNotification(_x, _x2, _x3) {
         return _sendNotification.apply(this, arguments);
@@ -73,7 +98,7 @@ var EmailNotificationStrategy = /*#__PURE__*/function () {
     }()
   }]);
   return EmailNotificationStrategy;
-}();
+}(NotificationStrategy);
 module.exports = {
   EmailNotificationStrategy: EmailNotificationStrategy
 };

package/dist/mailjetStrategy.js

@@ -17,6 +17,8 @@ function _assertThisInitialized(self) { if (self === void 0) { throw new Referen
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 var axios = require("axios");
+var _require = require("./baseStrategy"),
+  NotificationStrategy = _require.NotificationStrategy;
 
 /**
  * Mailjet SMS Notification Strategy.

package/dist/twilloStrategy.js

@@ -17,6 +17,8 @@ function _assertThisInitialized(self) { if (self === void 0) { throw new Referen
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 var twilio = require("twilio");
+var _require = require("./baseStrategy"),
+  NotificationStrategy = _require.NotificationStrategy;
 
 /**
  * Twilio SMS Notification Strategy class.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "propro-utils",
-  "version": "1.3.13",
+  "version": "1.3.15",
   "description": "Auth middleware for propro-auth",
   "main": "src/index.js",
   "scripts": {

package/src/server/index.js

@@ -4,8 +4,90 @@ const {
   exchangeToken,
   VerifyAccount,
 } = require("./middleware/verifyToken");
-const {refreshTokenMiddleware} = require("./middleware");
-// Main middleware function
+// const {refreshTokenMiddleware} = require("./middleware");
+
+const refreshLimiter = rateLimit({
+  windowMs: 15 * 60 * 1000, // 15 minutes
+  max: 100, // Limit each IP to 100 requests per 15 minutes
+  message: "Too many refresh requests from this IP, please try again after 15 minutes",
+});
+
+const refreshTokenCache = new Map();
+
+/**
+ * Middleware to refresh access token using refresh token.
+ *
+ * @param {Object} req - The request object.
+ * @param {Object} res - The response object.
+ * @param {Function} next - The next middleware function.
+ * @returns {void}
+ */
+async function refreshTokenMiddleware(req, res, next) {
+  refreshLimiter(req, res, async () => {
+    const refreshToken = req.cookies['x-refresh-token'];
+    if (!refreshToken) {
+      return res.status(401).json({ error: "No refresh token provided" });
+    }
+
+    if (!isValidRefreshTokenFormat(refreshToken)) {
+      return res.status(400).json({ error: "Invalid refresh token format" });
+    }
+
+    if (refreshTokenCache.has(refreshToken)) {
+      req.newAccessToken = refreshTokenCache.get(refreshToken);
+      return next();
+    }
+
+    try {
+      const response = await axios.post(
+          `${process.env.AUTH_URL}/oauth/token`,
+          new URLSearchParams({
+            grant_type: "refresh_token",
+            refresh_token: refreshToken,
+            client_id: process.env.CLIENT_ID,
+            client_secret: process.env.CLIENT_SECRET,
+          }),
+          { headers: { "Content-Type": "application/x-www-form-urlencoded" } }
+      );
+
+      if (response.data && response.data.access_token) {
+        refreshTokenCache.set(refreshToken, response.data.access_token);
+        req.newAccessToken = response.data.access_token;
+        next();
+      } else {
+        res.status(401).json({ error: "Unable to refresh token" });
+      }
+    } catch (error) {
+      const statusCode = error.response?.status || 500;
+      res.status(statusCode).json({ error: error.response?.data?.error || "Error refreshing token" });
+    }
+  });
+}
+
+/**
+ * Checks if the given token has a valid refresh token format.
+ *
+ * @param {string} token - The token to validate.
+ *
+ * @return {boolean} - Returns true if the token has a valid refresh token format, otherwise false.
+ */
+function isValidRefreshTokenFormat(token) {
+  const jwtPattern = /^[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]+$/;
+  return jwtPattern.test(token);
+}
+/**
+ * Middleware for handling authentication and authorization.
+ *
+ * @param {object} [options={}] - The options for configuring the authentication middleware.
+ * @param {string} [options.secret="RESTFULAPIs"] - The secret key used for authentication.
+ * @param {string} [options.authUrl=process.env.AUTH_URL] - The authentication URL.
+ * @param {string} [options.clientId=process.env.CLIENT_ID] - The client ID.
+ * @param {string} [options.clientSecret=process.env.CLIENT_SECRET] - The client secret.
+ * @param {string} [options.clientUrl=process.env.CLIENT_URL] - The client URL.
+ * @param {string} [options.redirectUri=process.env.REDIRECT_URI] - The redirect URI.
+ * @param {string} [options.appName=process.env.APP_NAME] - The application name.
+ * @returns {Function} - Express middleware function.
+ */
 function proproAuthMiddleware(options = {}) {
   const {
     secret = "RESTFULAPIs",
@@ -19,44 +101,6 @@ function proproAuthMiddleware(options = {}) {
 
   return async (req, res, next) => {
     try {
-      let token;
-      if (req.headers.authorization?.startsWith("Bearer ")) {
-        token = req.headers.authorization.split(" ")[1];
-      }  else if (req.cookies && req.cookies['x-access-token']) {
-        token = req.cookies['x-access-token'];
-      }
-
-      if (token) {
-        console.log("verifying access token", token);
-        const verifiedToken = await verifyJWT(token);
-        console.log("verifiedToken", verifiedToken);
-        if (verifiedToken) {
-          req.account = verifiedToken;
-          return next();
-        } else if (req.cookies && req.cookies['x-refresh-token']) {
-          const refreshToken = req.cookies['x-refresh-token'];
-          if (refreshToken) {
-            const newTokenData = await refreshTokenMiddleware(req, res, next);
-            if (newTokenData) {
-              res.cookie("x-refresh-token", newTokenData.tokens.refresh.token, {
-                httpOnly: true,
-                secure: process.env.NODE_ENV === "production",
-              });
-
-              res.cookie("x-access-token", newTokenData.tokens.access.token, {
-                httpOnly: true,
-                secure: process.env.NODE_ENV === "production",
-              });
-
-              req.account = verifyJWT(newTokenData.tokens.access.token, secret);
-            }
-          }
-        }
-      } else {
-        req.account = undefined;
-        res.status(401).send("Unauthorized: Invalid or expired token");
-      }
-
       if (!["/api/auth", "/api/callback"].includes(req.path)) {
         return next();
       }
@@ -106,4 +150,4 @@ function proproAuthMiddleware(options = {}) {
   };
 }
 
-module.exports = proproAuthMiddleware;
+module.exports = {proproAuthMiddleware, refreshTokenMiddleware};

package/src/server/middleware/refreshToken.js

@@ -24,23 +24,31 @@ const refreshLimiter = rateLimit({
  * @returns {Promise<void>} - Promise object that represents the completion of the middleware function.
  */
 const refreshTokenMiddleware = async (req, res, next) => {
+  console.log("refreshTokenMiddleware again");
   // Apply rate limiting
   refreshLimiter(req, res, async () => {
     const refreshToken = req.headers["x-refresh-token"];
 
+    console.log("refreshToken", refreshToken);
     if (!refreshToken) {
-      return res.status(401).json({ error: "No refresh token provided" });
+      res.status(401).json({ error: "No refresh token provided" });
     }
 
+    console.log("isValidRefreshTokenFormat(refreshToken)", isValidRefreshTokenFormat(refreshToken));
+
     if (!isValidRefreshTokenFormat(refreshToken)) {
-      return res.status(400).json({ error: "Invalid refresh token format" });
+      res.status(400).json({ error: "Invalid refresh token format" });
     }
 
+    console.log("refreshTokenCache.has(refreshToken)", refreshTokenCache.has(refreshToken));
+
     if (refreshTokenCache.has(refreshToken)) {
       req.newAccessToken = refreshTokenCache.get(refreshToken);
-      return next();
+      next();
     }
 
+    console.log("process.env.AUTH_URL", process.env.AUTH_URL);
+
     try {
       const response = await axios.post(
         `${process.env.AUTH_URL}/oauth/token`,
@@ -53,17 +61,19 @@ const refreshTokenMiddleware = async (req, res, next) => {
         { headers: { "Content-Type": "application/x-www-form-urlencoded" } }
       );
 
+      console.log("response", response);
+
       if (response.data && response.data.access_token) {
         refreshTokenCache.set(refreshToken, response.data.access_token);
         req.newAccessToken = response.data.access_token;
-        return next();
+        next();
       } else {
-        return res.status(401).json({ error: "Unable to refresh token" });
+        res.status(401).json({ error: "Unable to refresh token" });
       }
     } catch (error) {
       const statusCode = error.response?.status || 500;
       const message = error.response?.data?.error || "Error refreshing token";
-      return res.status(statusCode).json({ error: message });
+      res.status(statusCode).json({ error: message });
     }
   });
 };