@bluemarble/bm-components 1.4.0 → 1.4.2

package/dist/index.mjs

@@ -4232,6 +4232,320 @@ function useFormHelper() {
   });
 }
 
+// src/helpers/authHelper.ts
+import { serialize } from "cookie";
+import { parseCookies, setCookie } from "nookies";
+
+// node_modules/uuid/dist/esm-node/rng.js
+import crypto from "crypto";
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    crypto.randomFillSync(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+
+// node_modules/uuid/dist/esm-node/stringify.js
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
+}
+
+// node_modules/uuid/dist/esm-node/native.js
+import crypto2 from "crypto";
+var native_default = {
+  randomUUID: crypto2.randomUUID
+};
+
+// node_modules/uuid/dist/esm-node/v4.js
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random || (options.rng || rng)();
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default = v4;
+
+// src/helpers/authHelper.ts
+import jwt from "jsonwebtoken";
+function decodeSessionToken({
+  req,
+  res,
+  sessionTokenName,
+  validate
+}) {
+  var _a;
+  const token = ((_a = req.headers.authorization) == null ? void 0 : _a.split(" ")[1]) || req.cookies[sessionTokenName];
+  if (!token)
+    return res.status(401).json({ error: "Token inv\xE1lido", code: "token.invalid" });
+  const jwtDecode = (token2) => {
+    if (validate) {
+      return jwt.verify(token2, process.env.JWT_SECRET);
+    }
+    return jwt.decode(token2);
+  };
+  try {
+    const decoded = jwtDecode(token);
+    req.user = decoded.sub;
+    return;
+  } catch (error) {
+    return res.status(401).json({ error: "Token inv\xE1lido", code: "token.expired" });
+  }
+}
+var AuthHelper = class {
+  constructor({
+    cookies,
+    oauth,
+    tokenExpTimeInSeconds,
+    onLogin,
+    onValidateRefreshToken,
+    onInvalidateRefreshToken,
+    onCreateRefreshToken,
+    onGetUserData
+  }) {
+    this.generateJwtAndRefreshToken = (_0, ..._1) => __async(this, [_0, ..._1], function* (userId, payload = {}) {
+      const token = jwt.sign(payload, process.env.JWT_SECRET, {
+        subject: String(userId),
+        expiresIn: this.tokenExpTimeInSeconds || 60 * 15
+        // 15 minutos
+      });
+      const uniqueToken = v4_default();
+      yield this.onCreateRefreshToken(userId, uniqueToken);
+      return {
+        token,
+        refreshToken: uniqueToken
+      };
+    });
+    this.invalidateCookies = (res) => {
+      return res.setHeader("Set-Cookie", [
+        serialize(this.cookies.sessionToken, "", {
+          maxAge: -1,
+          path: "/"
+        }),
+        serialize(this.cookies.refreshToken, "", {
+          maxAge: -1,
+          path: "/"
+        })
+      ]);
+    };
+    this.cookies = cookies;
+    this.oauth = oauth;
+    this.tokenExpTimeInSeconds = tokenExpTimeInSeconds;
+    this.onLogin = onLogin;
+    this.onValidateRefreshToken = onValidateRefreshToken;
+    this.onInvalidateRefreshToken = onInvalidateRefreshToken;
+    this.onCreateRefreshToken = onCreateRefreshToken;
+    this.onGetUserData = onGetUserData;
+  }
+  handler(req, res) {
+    return __async(this, null, function* () {
+      if (!req.url)
+        return res.status(400).json({ error: "url not sent" });
+      if (req.url.endsWith("/login")) {
+        const loginResult = yield this.onLogin(req.body);
+        if (loginResult.status === "sucess") {
+          const { refreshToken, token } = yield this.generateJwtAndRefreshToken(
+            loginResult.userId,
+            {}
+          );
+          setCookie({ res }, this.cookies.sessionToken, token, {
+            secure: true,
+            maxAge: 60 * 60 * 24 * 30,
+            // 30 days
+            path: "/",
+            sameSite: true
+          });
+          setCookie({ res }, this.cookies.refreshToken, refreshToken, {
+            secure: true,
+            maxAge: 60 * 60 * 24 * 30,
+            // 30 days
+            path: "/",
+            sameSite: true,
+            httpOnly: true
+          });
+          return res.json({ token, refreshToken });
+        }
+        throw new HttpError(400, loginResult.response);
+      }
+      if (req.url.endsWith("/logout")) {
+        this.invalidateCookies(res).end();
+      }
+      if (req.url.endsWith("/refresh")) {
+        decodeSessionToken({
+          req,
+          res,
+          sessionTokenName: this.cookies.sessionToken,
+          validate: false
+        });
+        const userId = String(req.user);
+        const refreshToken = parseCookies({ req })[this.cookies.refreshToken];
+        if (!refreshToken) {
+          return this.invalidateCookies(res).status(400).json({
+            error: "Refresh Token n\xE3o encontrado"
+          });
+        }
+        const isValidRefreshToken = yield this.onValidateRefreshToken(
+          userId,
+          refreshToken
+        );
+        if (!isValidRefreshToken) {
+          return this.invalidateCookies(res).status(400).json({
+            error: "Refresh Token inv\xE1lido"
+          });
+        }
+        yield this.onInvalidateRefreshToken(userId, refreshToken);
+        const { token, refreshToken: newRefreshToken } = yield this.generateJwtAndRefreshToken(userId, {});
+        setCookie({ res }, this.cookies.sessionToken, token, {
+          secure: true,
+          maxAge: 60 * 60 * 24 * 30,
+          // 30 days
+          path: "/",
+          sameSite: true
+        });
+        setCookie({ res }, this.cookies.refreshToken, newRefreshToken, {
+          secure: true,
+          maxAge: 60 * 60 * 24 * 30,
+          // 30 days
+          path: "/",
+          sameSite: true,
+          httpOnly: true
+        });
+        return res.json({
+          token,
+          refreshToken: newRefreshToken
+        });
+      }
+      if (req.url.endsWith("/me")) {
+        decodeSessionToken({
+          req,
+          res,
+          sessionTokenName: this.cookies.sessionToken,
+          validate: true
+        });
+        if (!req.user)
+          return res.status(400).json({ error: "Usu\xE1rio n\xE3o encontrado" });
+        const userData = yield this.onGetUserData(req.user);
+        if (!userData)
+          return res.status(400).json({ error: "Usu\xE1rio n\xE3o encontrado" });
+        return res.json(userData);
+      }
+      if (req.url.endsWith("/oauth-url") && this.oauth) {
+        const params = {
+          client_id: this.oauth.client_id,
+          redirect_uri: this.oauth.redirect_uri,
+          scope: this.oauth.scope,
+          response_type: "code",
+          response_mode: "query"
+        };
+        const url = `https://login.microsoftonline.com/${this.oauth.tenant_id}/oauth2/v2.0/authorize?${new URLSearchParams(params)}`;
+        return res.json({
+          url
+        });
+      }
+      return res.status(404).json({ error: "Route not found" });
+    });
+  }
+  oauthSignInCallback(code) {
+    return __async(this, null, function* () {
+      if (!this.oauth)
+        throw new Error("OAUTH variables is not defined");
+      const body = {
+        client_id: this.oauth.client_id,
+        scope: this.oauth.scope,
+        code,
+        session_state: this.oauth.client_id,
+        redirect_uri: this.oauth.redirect_uri,
+        grant_type: "authorization_code",
+        client_secret: this.oauth.client_secret
+      };
+      const response = yield fetch(
+        `https://login.microsoftonline.com/${this.oauth.tenant_id}/oauth2/v2.0/token`,
+        {
+          method: "POST",
+          body: new URLSearchParams(body),
+          headers: { "Content-Type": "application/x-www-form-urlencoded" }
+        }
+      );
+      const data = yield response.json();
+      const decodedToken = jwt.decode(data.access_token);
+      const email = decodedToken.upn;
+      const fullName = `${decodedToken == null ? void 0 : decodedToken.given_name} ${decodedToken == null ? void 0 : decodedToken.family_name}`;
+      return { decodedToken, email, fullName };
+    });
+  }
+  createOauthCallbackGetServerSideProps({
+    onSuccessDestination,
+    onFailedDestination
+  }) {
+    return (ctx) => __async(this, null, function* () {
+      if (!this.oauth)
+        throw new Error("Oauth env variables are not defined");
+      const code = ctx.query.code;
+      if (!code)
+        return {
+          redirect: {
+            permanent: false,
+            destination: onFailedDestination || "/"
+          }
+        };
+      try {
+        const { fullName, email } = yield this.oauthSignInCallback(code);
+        const userExists = this.onGetUserData(email);
+        if (!userExists && this.oauth) {
+          this.oauth.onCreateUser({ fullname: fullName, email });
+        }
+        const { token, refreshToken } = yield this.generateJwtAndRefreshToken(
+          email,
+          {}
+        );
+        setCookie(ctx, this.cookies.sessionToken, token, {
+          secure: true,
+          maxAge: 60 * 60 * 24 * 30,
+          // 30 days
+          path: "/"
+        });
+        setCookie(ctx, this.cookies.refreshToken, refreshToken, {
+          secure: true,
+          maxAge: 60 * 60 * 24 * 30,
+          // 30 days
+          path: "/",
+          httpOnly: true
+        });
+        return {
+          redirect: {
+            destination: onSuccessDestination,
+            permanent: false
+          }
+        };
+      } catch (error) {
+        console.log(error);
+        return {
+          props: {
+            destination: onFailedDestination || "/"
+          }
+        };
+      }
+    });
+  }
+};
+
 // src/hooks/useGrid.ts
 import { useMemo as useMemo3, useState as useState6 } from "react";
 
@@ -4465,13 +4779,86 @@ function useEvent(event, handler, passive = false) {
     };
   });
 }
+
+// src/contexts/AuthContext.tsx
+import React27 from "react";
+import {
+  createContext as createContext3,
+  useEffect as useEffect6,
+  useState as useState7
+} from "react";
+import { parseCookies as parseCookies2 } from "nookies";
+function createAuthContext() {
+  return createContext3({});
+}
+function CreateAuthProvider({
+  api,
+  children,
+  sessionTokenName,
+  Provider
+}) {
+  const [user, setUser] = useState7();
+  const [status, setStatus] = useState7("unauthenticated");
+  const { createAlert } = useAlert();
+  const signIn = (_0) => __async(this, [_0], function* ({ email, password }) {
+    setStatus("loading");
+    try {
+      const response = yield api.post("/auth/login", {
+        email,
+        password
+      });
+      const { token } = response.data;
+      api.defaults.headers.common.Authorization = `Bearer ${token}`;
+      const { data } = yield api.get("/auth/me");
+      setUser(data);
+      setStatus("autenticated");
+      return true;
+    } catch (error) {
+      createAlert(error.response.data.error, "error");
+      setStatus("unauthenticated");
+      throw error;
+    }
+  });
+  function ClientSignOut() {
+    return __async(this, null, function* () {
+      yield api.get("/auth/logout");
+      setUser(void 0);
+    });
+  }
+  useEffect6(() => {
+    const token = parseCookies2()[sessionTokenName];
+    if (token) {
+      setStatus("loading");
+      api.get("/auth/me").then((response) => {
+        setStatus("autenticated");
+        setUser(response.data);
+      }).catch(() => {
+        setStatus("unauthenticated");
+      });
+    }
+  }, [api, sessionTokenName]);
+  return /* @__PURE__ */ React27.createElement(
+    Provider,
+    {
+      value: {
+        user,
+        signOut: ClientSignOut,
+        signIn,
+        status
+      }
+    },
+    children
+  );
+}
 export {
   AlertContext,
   AlertProvider,
   ApiHelper,
+  AuthHelper,
   Autocomplete2 as Autocomplete,
   BaseGrid,
   Checkbox,
+  CreateAuthProvider,
   Dialog,
   EditableTableCell,
   FormHelperContext,
@@ -4489,6 +4876,7 @@ export {
   TabPanel,
   Td,
   Tr,
+  createAuthContext,
   createFilter,
   filterData,
   getTabProps,