@bluemarble/bm-components 2.4.2 → 2.4.3

package/dist/index.js

@@ -1179,6 +1179,114 @@ var require_react_is2 = __commonJS({
   }
 });
 
+// packages/nookies/index.ts
+import * as cookie from "cookie";
+import * as setCookieParser from "set-cookie-parser";
+
+// packages/nookies/util.ts
+function isBrowser() {
+  return typeof window !== "undefined";
+}
+function createCookie(name, value, options) {
+  let sameSite = options.sameSite;
+  if (sameSite === true) {
+    sameSite = "strict";
+  }
+  if (sameSite === void 0 || sameSite === false) {
+    sameSite = "lax";
+  }
+  const cookieToSet = { ...options, sameSite };
+  delete cookieToSet.encode;
+  return {
+    name,
+    value,
+    ...cookieToSet
+  };
+}
+function hasSameProperties(a, b) {
+  const aProps = Object.getOwnPropertyNames(a);
+  const bProps = Object.getOwnPropertyNames(b);
+  if (aProps.length !== bProps.length) {
+    return false;
+  }
+  for (let i = 0; i < aProps.length; i++) {
+    const propName = aProps[i];
+    if (a[propName] !== b[propName]) {
+      return false;
+    }
+  }
+  return true;
+}
+function areCookiesEqual(a, b) {
+  let sameSiteSame = a.sameSite === b.sameSite;
+  if (typeof a.sameSite === "string" && typeof b.sameSite === "string") {
+    sameSiteSame = a.sameSite.toLowerCase() === b.sameSite.toLowerCase();
+  }
+  return hasSameProperties(
+    { ...a, sameSite: void 0 },
+    { ...b, sameSite: void 0 }
+  ) && sameSiteSame;
+}
+
+// packages/nookies/index.ts
+function parseCookies(ctx, options) {
+  if (ctx?.req?.headers?.cookie) {
+    return cookie.parse(ctx.req.headers.cookie, options);
+  }
+  if (isBrowser()) {
+    return cookie.parse(document.cookie, options);
+  }
+  return {};
+}
+function setCookie(ctx, name, value, options = {}) {
+  if (ctx?.res?.getHeader && ctx.res.setHeader) {
+    if (ctx?.res?.finished) {
+      console.warn(`Not setting "${name}" cookie. Response has finished.`);
+      console.warn(`You should set cookie before res.send()`);
+      return {};
+    }
+    let cookies = ctx.res.getHeader("Set-Cookie") || [];
+    if (typeof cookies === "string") cookies = [cookies];
+    if (typeof cookies === "number") cookies = [];
+    const parsedCookies = setCookieParser.parse(cookies, {
+      decodeValues: false
+    });
+    const newCookie = createCookie(name, value, options);
+    let cookiesToSet = [];
+    parsedCookies.forEach((parsedCookie) => {
+      if (!areCookiesEqual(parsedCookie, newCookie)) {
+        const serializedCookie = cookie.serialize(
+          parsedCookie.name,
+          parsedCookie.value,
+          {
+            // we prevent reencoding by default, but you might override it
+            encode: (val) => val,
+            ...parsedCookie
+          }
+        );
+        cookiesToSet.push(serializedCookie);
+      }
+    });
+    cookiesToSet.push(cookie.serialize(name, value, options));
+    ctx.res.setHeader("Set-Cookie", cookiesToSet);
+  }
+  if (isBrowser()) {
+    if (options && options.httpOnly) {
+      throw new Error("Can not set a httpOnly cookie in the browser.");
+    }
+    document.cookie = cookie.serialize(name, value, options);
+  }
+  return {};
+}
+function destroyCookie(ctx, name, options) {
+  return setCookie(ctx, name, "", { ...options || {}, maxAge: -1 });
+}
+var nookies = {
+  set: setCookie,
+  get: parseCookies,
+  destroy: destroyCookie
+};
+
 // src/components/Grid/Grid.tsx
 import React7, {
   useEffect,
@@ -4480,1222 +4588,1110 @@ var BaseDialog = {
   Body: BaseDialogBody
 };
 
-// src/errors/HttpError.ts
-var HttpError = class extends Error {
-  constructor(status, message) {
-    super(message);
-    this.message = message;
-    this.stack = `HttpError: ${message}`;
-    this.status = status;
-  }
+// src/contexts/FormHelperProvider.tsx
+import React30 from "react";
+import { createContext as createContext3 } from "react";
+var FormHelperContext = createContext3({});
+var FormHelperProvider = ({ formatErrorMessage, api, children }) => {
+  return /* @__PURE__ */ React30.createElement(FormHelperContext.Provider, { value: { formatErrorMessage, api } }, children);
 };
 
-// src/errors/DomainError.ts
-var DomainError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.message = message;
-    this.stack = `DomainError: ${message}`;
-  }
-};
+// src/contexts/AlertContext.tsx
+import React32, { useCallback as useCallback2 } from "react";
+import { createContext as createContext4, useState as useState6 } from "react";
 
-// src/helpers/apiHelper/index.ts
-var VALID_METHODS = [
-  "GET",
-  "HEAD",
-  "POST",
-  "PUT",
-  "DELETE",
-  "CONNECT",
-  "OPTIONS",
-  "TRACE",
-  "PATCH"
-];
-var _ApiHelper = class _ApiHelper {
-  async onFinally(_req, _res) {
-  }
-  async onError(_req, _res, _error) {
-  }
-  constructor(props) {
-    this.public = props?.public ?? false;
-    this.middlewares = (props?.middlewares || []).reverse();
-    this.onFinally = props?.onFinally || (async () => {
-    });
-    this.onError = props?.onError || (async () => {
-    });
-  }
-  createMethods(methods) {
-    return async (req, res) => {
-      const currentMethod = methods[req.method] || methods.ALL;
-      const options = { public: this.public };
-      if (req.method === "OPTIONS") return res.status(200).end();
-      try {
-        if (!VALID_METHODS.includes(req.method))
-          throw new HttpError(405, "M\xE9todo inv\xE1lido");
-        if (!currentMethod) throw new HttpError(500, "M\xE9todo n\xE3o encontrado");
-        const methodWithMiddlewares = this.middlewares.reduce(
-          (acc, fn) => fn(acc, options),
-          currentMethod
-        );
-        return await methodWithMiddlewares(req, res, options);
-      } catch (error) {
-        if (error instanceof DomainError) return res.status(400).json(error.message);
-        if (error instanceof HttpError) return res.status(error.status).json(error.message);
-        this.onError(req, res, error);
-        throw error;
-      } finally {
-        await this.onFinally(req, res);
-      }
-    };
-  }
-  buildFactory(factory) {
-    const options = {
-      public: this.public
-    };
-    return async (req, res) => {
-      const methods = factory(req, res);
-      const handler = methods[req.method];
-      if (!handler) throw new HttpError(405, "M\xE9todo inv\xE1lido");
-      const methodWithMiddlewares = this.middlewares.reduce((acc, fn) => {
-        return fn(acc, options);
-      }, handler);
-      return await methodWithMiddlewares(req, res, options);
-    };
-  }
-  static build(factory, options) {
-    const helper = new _ApiHelper({
-      ...options
-    }).buildFactory(factory);
-    return helper;
-  }
-  static parse(body, parser) {
-    try {
-      const object = parser.parse(body);
-      return object;
-    } catch (error) {
-      throw new HttpError(400, {
-        code: "invalid.body",
-        error: "Dados inv\xE1lidos",
-        details: error
-      });
-    }
-  }
-  /** @deprecated Use {@Link ApiHelper.build} instead. */
-  static create({ onFinally }) {
-    return new _ApiHelper({
-      onFinally
-    });
-  }
+// src/components/Toast/index.tsx
+import React31 from "react";
+import { Alert, IconButton as IconButton5, Snackbar } from "@mui/material";
+import { MdClose as MdClose3 } from "react-icons/md";
+var Toast = ({ open, onClose, severity, message }) => {
+  return /* @__PURE__ */ React31.createElement(React31.Fragment, null, /* @__PURE__ */ React31.createElement(
+    Snackbar,
+    {
+      open,
+      autoHideDuration: 6e3,
+      onClose,
+      anchorOrigin: { vertical: "top", horizontal: "right" },
+      sx: { zIndex: 99999999 }
+    },
+    /* @__PURE__ */ React31.createElement(
+      Alert,
+      {
+        severity,
+        elevation: 2,
+        action: /* @__PURE__ */ React31.createElement(
+          IconButton5,
+          {
+            "aria-label": "close",
+            color: "inherit",
+            size: "small",
+            onClick: onClose
+          },
+          /* @__PURE__ */ React31.createElement(MdClose3, { fontSize: "inherit" })
+        )
+      },
+      message
+    )
+  ));
 };
-/** @deprecated Use {@link ApiHelper.parser} instead. */
-_ApiHelper.parserErrorWrapper = _ApiHelper.parse;
-var ApiHelper = _ApiHelper;
-
-// src/helpers/authHelper.ts
-import { serialize as serialize2 } from "cookie";
-import jwt from "jsonwebtoken";
-
-// packages/nookies/index.ts
-import * as cookie from "cookie";
-import * as setCookieParser from "set-cookie-parser";
 
-// packages/nookies/util.ts
-function isBrowser() {
-  return typeof window !== "undefined";
+// src/contexts/AlertContext.tsx
+var AlertContext = createContext4({});
+var AlertProvider = ({ children }) => {
+  const [severity, setSeverity] = useState6("info");
+  const [message, setMessage] = useState6("");
+  const [isVisible, setIsVisible] = useState6(false);
+  const createAlert = useCallback2(
+    (newMessage, severity2) => {
+      setMessage(newMessage);
+      setSeverity(severity2);
+      setIsVisible(true);
+    },
+    []
+  );
+  const onCloseToast = useCallback2(() => {
+    setIsVisible(false);
+  }, []);
+  return /* @__PURE__ */ React32.createElement(AlertContext.Provider, { value: { createAlert } }, children, /* @__PURE__ */ React32.createElement(
+    Toast,
+    {
+      open: isVisible,
+      onClose: onCloseToast,
+      severity,
+      message
+    }
+  ));
+};
+
+// src/contexts/AuthContext.tsx
+import React33, { useCallback as useCallback8 } from "react";
+import {
+  createContext as createContext5,
+  useEffect as useEffect8,
+  useState as useState11
+} from "react";
+
+// src/hooks/useGrid.ts
+import { useCallback as useCallback4, useEffect as useEffect4, useMemo as useMemo3, useState as useState8 } from "react";
+
+// src/hooks/useFilter.ts
+import { useCallback as useCallback3, useState as useState7 } from "react";
+
+// src/components/utils/getObjectValue.ts
+function getObjectValue(obj) {
+  return (prop) => {
+    try {
+      return prop.split(".").reduce((o, k) => o[k], obj);
+    } catch (_) {
+      return void 0;
+    }
+  };
 }
-function createCookie(name, value, options) {
-  let sameSite = options.sameSite;
-  if (sameSite === true) {
-    sameSite = "strict";
-  }
-  if (sameSite === void 0 || sameSite === false) {
-    sameSite = "lax";
+
+// src/hooks/useFilter.ts
+function useFilter(props = { defaultFilters: [] }) {
+  const [selectedFilters, setSelectedFilters] = useState7(() => {
+    const { defaultFilters } = props;
+    return defaultFilters || [];
+  });
+  const filterBy = useCallback3((newFilter) => {
+    const propToCompare = newFilter?.id ? "id" : "prop";
+    function removeRepeatedFilters(filter) {
+      return filter[propToCompare] !== newFilter[propToCompare];
+    }
+    setSelectedFilters((filters) => [
+      ...filters.filter(removeRepeatedFilters),
+      newFilter
+    ]);
+  }, []);
+  const removeFilter = useCallback3(
+    (prop, isId) => {
+      const propToCompare = isId ? "id" : "prop";
+      setSelectedFilters(
+        selectedFilters.filter((filter) => filter[propToCompare] !== prop)
+      );
+    },
+    [selectedFilters]
+  );
+  function clearAllFilters() {
+    setSelectedFilters([]);
   }
-  const cookieToSet = { ...options, sameSite };
-  delete cookieToSet.encode;
   return {
-    name,
-    value,
-    ...cookieToSet
+    filters: selectedFilters,
+    filterBy,
+    removeFilter,
+    createFilter,
+    clearAllFilters
   };
 }
-function hasSameProperties(a, b) {
-  const aProps = Object.getOwnPropertyNames(a);
-  const bProps = Object.getOwnPropertyNames(b);
-  if (aProps.length !== bProps.length) {
-    return false;
-  }
-  for (let i = 0; i < aProps.length; i++) {
-    const propName = aProps[i];
-    if (a[propName] !== b[propName]) {
-      return false;
-    }
-  }
-  return true;
+function isDate(date) {
+  if (date instanceof Date) return true;
+  else if (String(date).endsWith("Z")) return true;
+  return false;
 }
-function areCookiesEqual(a, b) {
-  let sameSiteSame = a.sameSite === b.sameSite;
-  if (typeof a.sameSite === "string" && typeof b.sameSite === "string") {
-    sameSiteSame = a.sameSite.toLowerCase() === b.sameSite.toLowerCase();
+function compareFilter(item, filter) {
+  const itemValue = getObjectValue(item)(filter.prop);
+  switch (filter.compareType) {
+    case "equal":
+      return itemValue === filter.value;
+    case "notEqual":
+      return itemValue !== filter.value;
+    case "in":
+      return filter.value.includes(itemValue);
+    case "notIn":
+      return !filter.value.includes(itemValue);
+    case "valueIn":
+      return itemValue.includes(filter.value);
+    case "valueNotIn":
+      return !itemValue.includes(filter.value);
+    case "gte":
+      return isDate(itemValue) ? new Date(String(itemValue)) >= filter.value : itemValue >= filter.value;
+    case "gt":
+      return isDate(itemValue) ? new Date(String(itemValue)) > filter.value : itemValue > filter.value;
+    case "lte":
+      return isDate(itemValue) ? new Date(String(itemValue)) <= filter.value : itemValue <= filter.value;
+    case "lt":
+      return isDate(itemValue) ? new Date(String(itemValue)) < filter.value : itemValue < filter.value;
   }
-  return hasSameProperties(
-    { ...a, sameSite: void 0 },
-    { ...b, sameSite: void 0 }
-  ) && sameSiteSame;
 }
-
-// packages/nookies/index.ts
-function parseCookies(ctx, options) {
-  if (ctx?.req?.headers?.cookie) {
-    return cookie.parse(ctx.req.headers.cookie, options);
-  }
-  if (isBrowser()) {
-    return cookie.parse(document.cookie, options);
+function createFilter(filters) {
+  function apply(item) {
+    const satisfiedFilters = filters.reduce((acc, filter) => {
+      if (compareFilter(item, filter)) acc += 1;
+      return acc;
+    }, 0);
+    return satisfiedFilters === filters.length;
   }
-  return {};
+  return {
+    apply
+  };
 }
-function setCookie(ctx, name, value, options = {}) {
-  if (ctx?.res?.getHeader && ctx.res.setHeader) {
-    if (ctx?.res?.finished) {
-      console.warn(`Not setting "${name}" cookie. Response has finished.`);
-      console.warn(`You should set cookie before res.send()`);
-      return {};
-    }
-    let cookies = ctx.res.getHeader("Set-Cookie") || [];
-    if (typeof cookies === "string") cookies = [cookies];
-    if (typeof cookies === "number") cookies = [];
-    const parsedCookies = setCookieParser.parse(cookies, {
-      decodeValues: false
-    });
-    const newCookie = createCookie(name, value, options);
-    let cookiesToSet = [];
-    parsedCookies.forEach((parsedCookie) => {
-      if (!areCookiesEqual(parsedCookie, newCookie)) {
-        const serializedCookie = cookie.serialize(
-          parsedCookie.name,
-          parsedCookie.value,
-          {
-            // we prevent reencoding by default, but you might override it
-            encode: (val) => val,
-            ...parsedCookie
-          }
-        );
-        cookiesToSet.push(serializedCookie);
+
+// src/helpers/sortHelper.ts
+function SortHelper(...fields) {
+  return (a, b) => {
+    for (const field of fields) {
+      let direction = 1;
+      let key = field;
+      if (field.startsWith("-")) {
+        direction = -1;
+        key = field.slice(1);
       }
-    });
-    cookiesToSet.push(cookie.serialize(name, value, options));
-    ctx.res.setHeader("Set-Cookie", cookiesToSet);
-  }
-  if (isBrowser()) {
-    if (options && options.httpOnly) {
-      throw new Error("Can not set a httpOnly cookie in the browser.");
+      const aVal = a[key];
+      const bVal = b[key];
+      if (aVal > bVal) return direction;
+      if (aVal < bVal) return -direction;
     }
-    document.cookie = cookie.serialize(name, value, options);
-  }
-  return {};
-}
-function destroyCookie(ctx, name, options) {
-  return setCookie(ctx, name, "", { ...options || {}, maxAge: -1 });
+    return 0;
+  };
 }
-var nookies = {
-  set: setCookie,
-  get: parseCookies,
-  destroy: destroyCookie
-};
 
-// src/helpers/authHelper.ts
-import { randomUUID } from "crypto";
-function decodeSessionToken({
-  req,
-  res,
-  sessionTokenName,
-  validate
+// src/hooks/useGrid.ts
+function useGrid({
+  columns,
+  filters,
+  search,
+  rowsPerPageOptions = [30, 60, 100],
+  defaultData: externalDefaultData,
+  defaultCurrentPage,
+  defaultSortedBy
 }) {
-  const token = req.headers.authorization?.split(" ")[1] || req.cookies[sessionTokenName];
-  if (!token) {
-    res.status(401).json({ error: "Token inv\xE1lido", code: "token.invalid" });
-    return true;
-  }
-  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;
-  } catch (_) {
-    res.status(401).json({ error: "Token inv\xE1lido", code: "token.expired" });
-    return true;
-  }
-}
-var AuthHelper = class {
-  constructor({
-    cookies,
-    oauth,
-    tokenExpTimeInSeconds,
-    onLogin,
-    onValidateRefreshToken,
-    onInvalidateRefreshToken,
-    onCreateRefreshToken,
-    onGetUserData
-  }) {
-    this.generateJwtAndRefreshToken = async (userId, payload = {}) => {
-      const token = jwt.sign(payload, process.env.JWT_SECRET, {
-        subject: String(userId),
-        expiresIn: this.tokenExpTimeInSeconds || 60 * 15
-        // 15 minutos
-      });
-      const uniqueToken = randomUUID();
-      await this.onCreateRefreshToken(userId, uniqueToken);
-      return {
-        token,
-        refreshToken: uniqueToken
-      };
-    };
-    this.invalidateCookies = (res) => {
-      return res.setHeader("Set-Cookie", [
-        serialize2(this.cookies.sessionToken, "", {
-          maxAge: -1,
-          path: "/"
-        }),
-        serialize2(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;
-  }
-  async handler(req, res) {
-    if (!req.url) return res.status(400).json({ error: "url not sent" });
-    if (req.url.endsWith("/login")) {
-      const loginResult = await this.onLogin(req.body);
-      if (loginResult.status === "success") {
-        const { refreshToken, token } = await 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")) {
-      const error = decodeSessionToken({
-        req,
-        res,
-        sessionTokenName: this.cookies.sessionToken,
-        validate: false
-      });
-      if (error) return;
-      const userId = String(req.user);
-      const refreshToken = parseCookies({ req })[this.cookies.refreshToken];
-      if (!refreshToken) {
-        this.invalidateCookies(res);
-        return res.status(400).json({
-          error: "Refresh Token inv\xE1lido"
-        });
-      }
-      const isValidRefreshToken = await this.onValidateRefreshToken(
-        userId,
-        refreshToken
-      );
-      if (!isValidRefreshToken) {
-        this.invalidateCookies(res);
-        return res.status(400).json({
-          error: "Refresh Token inv\xE1lido"
-        });
-      }
-      await this.onInvalidateRefreshToken(userId, refreshToken);
-      const { token, refreshToken: newRefreshToken } = await 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")) {
-      const error = decodeSessionToken({
-        req,
-        res,
-        sessionTokenName: this.cookies.sessionToken,
-        validate: true
-      });
-      if (error) return;
-      if (!req.user)
-        return res.status(400).json({ error: "Usu\xE1rio n\xE3o encontrado" });
-      const userData = await 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" });
-  }
-  async oauthSignInCallback(code) {
-    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 = await 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 = await response.json();
-    const decodedToken = jwt.decode(data.access_token);
-    const email = decodedToken.upn;
-    const fullName = `${decodedToken?.given_name} ${decodedToken?.family_name}`;
-    return { decodedToken, email, fullName };
-  }
-  createOauthCallbackGetServerSideProps({
-    onSuccessDestination,
-    onFailedDestination
-  }) {
-    return async (ctx) => {
-      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 } = await this.oauthSignInCallback(code);
-        const userExists = await this.onGetUserData(email);
-        if (!userExists && !this.oauth.onCreateUser)
-          throw new Error("User does not exists");
-        if (!userExists && this.oauth.onCreateUser) {
-          await this.oauth.onCreateUser({ fullname: fullName, email });
+  const [defaultData, setDefaultData] = useState8(externalDefaultData || []);
+  const [sortedBy, setSortedBy] = useState8(
+    defaultSortedBy || []
+  );
+  const [currentPage, setCurrentPage] = useState8(defaultCurrentPage || 0);
+  const [rowsPerPage, setRowsPerPage] = useState8(rowsPerPageOptions[0]);
+  const toggleSortedDirection = useCallback4(
+    (direction) => {
+      if (direction === "asc") return "desc";
+      return "asc";
+    },
+    []
+  );
+  const clearSort = useCallback4(() => {
+    setSortedBy([]);
+  }, []);
+  const appendSort = useCallback4((prop, direction) => {
+    setSortedBy((prev) => [...prev, { prop, direction }]);
+  }, []);
+  const setSort = useCallback4((prop, direction) => {
+    setSortedBy([{ prop, direction }]);
+  }, []);
+  const onSortBy = useCallback4(
+    (prop) => {
+      if (!prop) return;
+      const currentSorted = sortedBy.find((p) => p.prop === prop);
+      if (currentSorted) {
+        if (currentSorted.direction === "asc") {
+          setSortedBy((prev) => prev.filter((p) => p.prop !== prop));
+        } else {
+          setSortedBy((prev) => {
+            const newArr = prev.map((p) => {
+              if (p.prop !== prop) return p;
+              return {
+                prop: p.prop,
+                direction: toggleSortedDirection(p.direction)
+              };
+            });
+            return [...newArr].slice(0);
+          });
         }
-        const { token, refreshToken } = await 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) {
-        return {
-          props: {
-            error: JSON.stringify(error)
-          }
-        };
+      } else {
+        setSortedBy((prev) => [...prev, { prop, direction: "desc" }]);
       }
-    };
-  }
-};
-
-// src/hooks/useGrid.ts
-import { useCallback as useCallback3, useEffect as useEffect4, useMemo as useMemo3, useState as useState7 } from "react";
-
-// src/hooks/useFilter.ts
-import { useCallback as useCallback2, useState as useState6 } from "react";
-
-// src/components/utils/getObjectValue.ts
-function getObjectValue(obj) {
-  return (prop) => {
-    try {
-      return prop.split(".").reduce((o, k) => o[k], obj);
-    } catch (_) {
-      return void 0;
-    }
-  };
-}
-
-// src/hooks/useFilter.ts
-function useFilter(props = { defaultFilters: [] }) {
-  const [selectedFilters, setSelectedFilters] = useState6(() => {
-    const { defaultFilters } = props;
-    return defaultFilters || [];
-  });
-  const filterBy = useCallback2((newFilter) => {
-    const propToCompare = newFilter?.id ? "id" : "prop";
-    function removeRepeatedFilters(filter) {
-      return filter[propToCompare] !== newFilter[propToCompare];
-    }
-    setSelectedFilters((filters) => [
-      ...filters.filter(removeRepeatedFilters),
-      newFilter
-    ]);
+    },
+    [toggleSortedDirection, sortedBy]
+  );
+  const set = useCallback4((data) => {
+    setDefaultData(data);
   }, []);
-  const removeFilter = useCallback2(
-    (prop, isId) => {
-      const propToCompare = isId ? "id" : "prop";
-      setSelectedFilters(
-        selectedFilters.filter((filter) => filter[propToCompare] !== prop)
-      );
+  const sortData = useCallback4(
+    (data) => {
+      if (sortedBy.length > 0) {
+        const symbolDir = {
+          asc: "",
+          desc: "-"
+        };
+        const formattedKeys = sortedBy.map(
+          ({ prop, direction }) => `${symbolDir[direction]}${prop}`
+        );
+        return data.sort(SortHelper(...formattedKeys));
+      } else return data;
     },
-    [selectedFilters]
+    [sortedBy]
   );
-  function clearAllFilters() {
-    setSelectedFilters([]);
-  }
-  return {
-    filters: selectedFilters,
-    filterBy,
-    removeFilter,
-    createFilter,
-    clearAllFilters
+  const onPageChange = (pageNumber) => {
+    if (pageNumber < 0) return;
+    if (pageNumber > totalNumberOfPages) return;
+    setCurrentPage(pageNumber);
   };
-}
-function isDate(date) {
-  if (date instanceof Date) return true;
-  else if (String(date).endsWith("Z")) return true;
-  return false;
-}
-function compareFilter(item, filter) {
-  const itemValue = getObjectValue(item)(filter.prop);
-  switch (filter.compareType) {
-    case "equal":
-      return itemValue === filter.value;
-    case "notEqual":
-      return itemValue !== filter.value;
-    case "in":
-      return filter.value.includes(itemValue);
-    case "notIn":
-      return !filter.value.includes(itemValue);
-    case "valueIn":
-      return itemValue.includes(filter.value);
-    case "valueNotIn":
-      return !itemValue.includes(filter.value);
-    case "gte":
-      return isDate(itemValue) ? new Date(String(itemValue)) >= filter.value : itemValue >= filter.value;
-    case "gt":
-      return isDate(itemValue) ? new Date(String(itemValue)) > filter.value : itemValue > filter.value;
-    case "lte":
-      return isDate(itemValue) ? new Date(String(itemValue)) <= filter.value : itemValue <= filter.value;
-    case "lt":
-      return isDate(itemValue) ? new Date(String(itemValue)) < filter.value : itemValue < filter.value;
-  }
-}
-function createFilter(filters) {
-  function apply(item) {
-    const satisfiedFilters = filters.reduce((acc, filter) => {
-      if (compareFilter(item, filter)) acc += 1;
-      return acc;
-    }, 0);
-    return satisfiedFilters === filters.length;
-  }
+  const onChangeRowsPerPage = useCallback4(
+    (rows) => {
+      let totalNumberOfPages2 = Math.round(filteredData.length / rows) - 1;
+      totalNumberOfPages2 = totalNumberOfPages2 <= 0 ? 0 : 1;
+      if (currentPage > totalNumberOfPages2) setCurrentPage(totalNumberOfPages2);
+      setRowsPerPage(rows);
+    },
+    [currentPage]
+  );
+  const orderedData = useMemo3(() => {
+    if (sortedBy.length === 0) return defaultData;
+    const newData = defaultData.slice(0);
+    const sortedData = sortData(newData);
+    return sortedData;
+  }, [defaultData, sortData, sortedBy]);
+  const filteredData = useMemo3(() => {
+    let newData = orderedData.slice(0);
+    if (search && search.value !== "") {
+      const searchBy = createSearch(search);
+      newData = newData.filter(searchBy);
+    }
+    if (!filters) return newData;
+    const newFilter = createFilter(filters);
+    return newData.filter(newFilter.apply);
+  }, [orderedData, search, filters]);
+  const paginatedData = useMemo3(() => {
+    const startPage = currentPage * rowsPerPage;
+    const endPage = startPage + rowsPerPage;
+    return filteredData.slice(startPage, endPage);
+  }, [currentPage, rowsPerPage, filteredData]);
+  const totalNumberOfPages = Math.ceil(filteredData.length / rowsPerPage) - 1;
+  useEffect4(() => {
+    if (externalDefaultData) setDefaultData(externalDefaultData);
+  }, [externalDefaultData]);
   return {
-    apply
+    data: paginatedData,
+    orderedData,
+    filteredData,
+    defaultData,
+    sortedBy,
+    columns,
+    currentPage,
+    totalNumberOfPages: totalNumberOfPages < 0 ? 0 : totalNumberOfPages,
+    rowsPerPageOptions,
+    rowsPerPage,
+    set,
+    onSortBy,
+    onPageChange,
+    setRowsPerPage: onChangeRowsPerPage,
+    appendSort,
+    setSort,
+    clearSort
   };
 }
-
-// src/helpers/sortHelper.ts
-function SortHelper(...fields) {
-  return (a, b) => {
-    for (const field of fields) {
-      let direction = 1;
-      let key = field;
-      if (field.startsWith("-")) {
-        direction = -1;
-        key = field.slice(1);
-      }
-      const aVal = a[key];
-      const bVal = b[key];
-      if (aVal > bVal) return direction;
-      if (aVal < bVal) return -direction;
+var isNumberOrString = (value) => ["number", "string"].includes(typeof value);
+var concatenateKey = (key, prev) => {
+  if (!prev) return key;
+  return `${prev}.${key}`;
+};
+function searchKeysForValue(row, accKey, compare) {
+  if (typeof row === "undefined") return false;
+  const rowKeys = Object.keys(row);
+  let match = false;
+  for (const key of rowKeys) {
+    if (match) break;
+    const objValue = row[key];
+    if (!objValue) continue;
+    const concatenatedKey = concatenateKey(key, accKey);
+    if (Array.isArray(objValue)) {
+      match = objValue.some(
+        (obj) => isNumberOrString(obj) ? compare(concatenatedKey, obj) : searchKeysForValue(obj, concatenatedKey, compare)
+      );
+      continue;
     }
-    return 0;
+    if (typeof objValue === "object") {
+      match = searchKeysForValue(objValue, concatenatedKey, compare);
+      continue;
+    }
+    match = compare(concatenatedKey, row[key]);
+  }
+  return match;
+}
+var normalize = (str) => str.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+function createSearch(options) {
+  const searchValue = options.caseSensitive ? options.value : String(options.value).toLowerCase();
+  function getValue2(value) {
+    if (options.caseSensitive) return String(value);
+    return String(value).toLowerCase();
+  }
+  function compare(key, objValue) {
+    if (options.ignoredKeys) {
+      const isIgnoredKey = options.ignoredKeys.includes(key);
+      if (isIgnoredKey) return false;
+    }
+    const value = getValue2(objValue);
+    if (options.exact) return value === searchValue;
+    if (options.ignoreAccentMark) return normalize(value).includes(normalize(searchValue));
+    return value.includes(searchValue);
+  }
+  return (row) => {
+    const match = searchKeysForValue(row, "", compare);
+    return match;
   };
 }
 
-// src/hooks/useGrid.ts
-function useGrid({
+// src/hooks/useAsyncGrid.ts
+import { useCallback as useCallback5, useEffect as useEffect5, useState as useState9 } from "react";
+function useAsyncGrid({
   columns,
-  filters,
+  filters = [],
   search,
   rowsPerPageOptions = [30, 60, 100],
+  onRequest,
+  axiosInstance,
+  url,
   defaultData: externalDefaultData,
   defaultCurrentPage,
   defaultSortedBy
 }) {
-  const [defaultData, setDefaultData] = useState7(externalDefaultData || []);
-  const [sortedBy, setSortedBy] = useState7(
+  const [defaultData, setDefaultData] = useState9(externalDefaultData || []);
+  const [sortedBy, setSortedBy] = useState9(
     defaultSortedBy || []
   );
-  const [currentPage, setCurrentPage] = useState7(defaultCurrentPage || 0);
-  const [rowsPerPage, setRowsPerPage] = useState7(rowsPerPageOptions[0]);
-  const toggleSortedDirection = useCallback3(
-    (direction) => {
-      if (direction === "asc") return "desc";
-      return "asc";
+  const [totalNumberOfItems, setTotalNumberOfItems] = useState9(0);
+  const [isLoading, setIsLoading] = useState9(false);
+  const [currentPage, setCurrentPage] = useState9(defaultCurrentPage || 0);
+  const [rowsPerPage, setRowsPerPage] = useState9(rowsPerPageOptions[0]);
+  const totalNumberOfPages = Math.ceil(totalNumberOfItems / rowsPerPage) - 1;
+  const toggleSortedDirection = useCallback5(
+    (direction) => {
+      if (direction === "asc") return "desc";
+      return "asc";
+    },
+    []
+  );
+  const setSort = useCallback5((prop, direction) => {
+    setSortedBy((prev) => [...prev, { prop, direction }]);
+  }, []);
+  const onSortBy = useCallback5(
+    async (prop) => {
+      if (!prop) return;
+      let finalArr = [];
+      const currentSorted = sortedBy.find((p) => p.prop === prop);
+      if (currentSorted) {
+        if (currentSorted.direction === "asc") {
+          finalArr = sortedBy.filter((p) => p.prop !== prop);
+        } else {
+          finalArr = sortedBy.map((p) => {
+            if (p.prop !== prop) return p;
+            return {
+              prop: p.prop,
+              direction: toggleSortedDirection(p.direction)
+            };
+          });
+        }
+      } else {
+        finalArr = [...sortedBy, { prop, direction: "desc" }];
+      }
+      await updateGridContent({
+        page: currentPage,
+        sortedBy: finalArr,
+        rowsPerPage
+      });
+    },
+    [sortedBy, toggleSortedDirection, rowsPerPage, currentPage]
+  );
+  const set = useCallback5((data) => {
+    setDefaultData(data);
+  }, []);
+  const baseRequest = useCallback5(
+    async ({
+      page,
+      search: search2,
+      filters: filters2,
+      sortedBy: sortedBy2,
+      rowsPerPage: rowsPerPage2
+    }) => {
+      if (!axiosInstance) throw new Error("Axios instance not provided");
+      try {
+        const params = new URLSearchParams({
+          page: String(page),
+          rowsPerPage: String(rowsPerPage2),
+          searchText: search2?.value || "",
+          sort: sortedBy2.map(({ prop, direction }) => `${prop}:${direction}`).join(","),
+          filters: filters2.map(
+            (filter) => `${filter.prop}:${filter.compareType}:${filter.value}`
+          ).join(",")
+        });
+        const pathWithParams = `${url}?${params.toString()}`;
+        const { data } = await axiosInstance.get(pathWithParams);
+        setTotalNumberOfItems(data.totalNumberOfItems);
+        return data.rows;
+      } catch (_) {
+        return [];
+      }
+    },
+    [axiosInstance, url]
+  );
+  const updateGridContent = useCallback5(
+    async ({
+      page,
+      sortedBy: sortedBy2,
+      rowsPerPage: rowsPerPage2
+    }) => {
+      setIsLoading(true);
+      try {
+        const props = {
+          page,
+          rowsPerPage: rowsPerPage2,
+          sortedBy: sortedBy2,
+          search,
+          filters
+        };
+        const result = !onRequest ? await baseRequest(props) : await onRequest(props);
+        setSortedBy(sortedBy2);
+        setRowsPerPage(rowsPerPage2);
+        set(result);
+        setCurrentPage(page);
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [set, search, filters, onRequest, baseRequest]
+  );
+  const onPageChange = useCallback5(
+    (pageNumber) => {
+      if (pageNumber < 0) return;
+      if (pageNumber > totalNumberOfPages) return;
+      updateGridContent({ page: pageNumber, sortedBy, rowsPerPage });
+    },
+    [updateGridContent, totalNumberOfPages, sortedBy, rowsPerPage]
+  );
+  const onChangeRowsPerPage = useCallback5(
+    (rows) => {
+      let totalNumberOfPages2 = Math.round(totalNumberOfItems / rows) - 1;
+      totalNumberOfPages2 = totalNumberOfPages2 <= 0 ? 0 : 1;
+      if (currentPage > totalNumberOfPages2)
+        updateGridContent({
+          page: totalNumberOfPages2,
+          sortedBy,
+          rowsPerPage: rows
+        });
+      updateGridContent({
+        page: currentPage,
+        sortedBy,
+        rowsPerPage: rows
+      });
+    },
+    [updateGridContent, totalNumberOfItems, sortedBy, currentPage]
+  );
+  const displayData = defaultData;
+  useEffect5(() => {
+    updateGridContent({ page: 0, sortedBy: [], rowsPerPage });
+  }, [updateGridContent, rowsPerPage]);
+  return {
+    data: displayData,
+    set,
+    onSortBy,
+    sortedBy,
+    defaultData,
+    columns,
+    currentPage,
+    totalNumberOfPages: totalNumberOfPages < 0 ? 0 : totalNumberOfPages,
+    onPageChange,
+    setRowsPerPage: onChangeRowsPerPage,
+    rowsPerPageOptions,
+    rowsPerPage,
+    setSort,
+    isLoading,
+    setIsLoading
+  };
+}
+
+// src/hooks/useEvent.ts
+import { useEffect as useEffect6 } from "react";
+function useEvent(event, handler, passive = false) {
+  useEffect6(() => {
+    window.addEventListener(event, handler, passive);
+    return function cleanup() {
+      window.removeEventListener(event, handler);
+    };
+  });
+}
+
+// src/hooks/useLoading.ts
+import { useCallback as useCallback6, useState as useState10 } from "react";
+function useLoading() {
+  const [state, setState] = useState10([]);
+  const isLoading = useCallback6((prop) => state.includes(prop), [state]);
+  const setLoading = useCallback6((prop, remove) => {
+    if (remove)
+      setState((prevState) => prevState.filter((state2) => state2 !== prop));
+    else setState((prevState) => [...prevState, prop]);
+  }, []);
+  return { isLoading, setLoading };
+}
+
+// src/hooks/useAlert.ts
+import { useContext as useContext3 } from "react";
+var useAlert = () => {
+  return useContext3(AlertContext);
+};
+
+// src/hooks/useFormHelper.ts
+import { useCallback as useCallback7, useContext as useContext4, useEffect as useEffect7, useRef as useRef4 } from "react";
+function useFormHelper() {
+  const alertProps = useAlert();
+  const loadingProps = useLoading();
+  const { api, formatErrorMessage } = useContext4(FormHelperContext);
+  const { createAlert } = alertProps;
+  const { setLoading } = loadingProps;
+  const sourceRef = useRef4(new AbortController());
+  const onSubmitWrapper = useCallback7(
+    (fn, { name }) => {
+      return async (fields, methods) => {
+        const LOADING_NAME = name;
+        setLoading(LOADING_NAME);
+        try {
+          await fn(fields, methods);
+        } catch (error) {
+          errorHandler(error, methods.setErrors);
+        } finally {
+          setLoading(LOADING_NAME, true);
+        }
+      };
+    },
+    [setLoading]
+  );
+  const onRequestWrapper = useCallback7(
+    (fn, { name }) => {
+      return async (...params) => {
+        const LOADING_NAME = name;
+        setLoading(LOADING_NAME);
+        api.interceptors.request.use(
+          (config) => {
+            if (!config.signal && sourceRef.current && config.method === "get") {
+              config.signal = sourceRef.current.signal;
+            }
+            return config;
+          },
+          (error) => {
+            return Promise.reject(error);
+          }
+        );
+        try {
+          const response = await fn(...params);
+          return response;
+        } catch (error) {
+          errorHandler(error);
+        } finally {
+          setLoading(LOADING_NAME, true);
+        }
+      };
     },
-    []
+    [setLoading, api]
   );
-  const clearSort = useCallback3(() => {
-    setSortedBy([]);
-  }, []);
-  const appendSort = useCallback3((prop, direction) => {
-    setSortedBy((prev) => [...prev, { prop, direction }]);
-  }, []);
-  const setSort = useCallback3((prop, direction) => {
-    setSortedBy([{ prop, direction }]);
-  }, []);
-  const onSortBy = useCallback3(
-    (prop) => {
-      if (!prop) return;
-      const currentSorted = sortedBy.find((p) => p.prop === prop);
-      if (currentSorted) {
-        if (currentSorted.direction === "asc") {
-          setSortedBy((prev) => prev.filter((p) => p.prop !== prop));
-        } else {
-          setSortedBy((prev) => {
-            const newArr = prev.map((p) => {
-              if (p.prop !== prop) return p;
-              return {
-                prop: p.prop,
-                direction: toggleSortedDirection(p.direction)
-              };
-            });
-            return [...newArr].slice(0);
-          });
+  const errorHandler = useCallback7(
+    (error, callback) => {
+      if (error?.message === "cancel.navigation") return;
+      if (callback) {
+        if (error.response.data.code === "invalid.body") {
+          const errors = error.response.data.details.issues;
+          const currentErrors = errors.reduce((acc, item) => {
+            acc[item.path.join(".")] = item.message;
+            return acc;
+          }, {});
+          callback(currentErrors);
         }
-      } else {
-        setSortedBy((prev) => [...prev, { prop, direction: "desc" }]);
       }
+      createAlert(formatErrorMessage(error), "error");
     },
-    [toggleSortedDirection, sortedBy]
+    [formatErrorMessage, createAlert]
   );
-  const set = useCallback3((data) => {
-    setDefaultData(data);
+  useEffect7(() => {
+    return () => {
+      sourceRef.current.abort();
+      sourceRef.current = new AbortController();
+    };
   }, []);
-  const sortData = useCallback3(
-    (data) => {
-      if (sortedBy.length > 0) {
-        const symbolDir = {
-          asc: "",
-          desc: "-"
-        };
-        const formattedKeys = sortedBy.map(
-          ({ prop, direction }) => `${symbolDir[direction]}${prop}`
-        );
-        return data.sort(SortHelper(...formattedKeys));
-      } else return data;
-    },
-    [sortedBy]
-  );
-  const onPageChange = (pageNumber) => {
-    if (pageNumber < 0) return;
-    if (pageNumber > totalNumberOfPages) return;
-    setCurrentPage(pageNumber);
+  return {
+    ...alertProps,
+    ...loadingProps,
+    onSubmitWrapper,
+    onRequestWrapper
   };
-  const onChangeRowsPerPage = useCallback3(
-    (rows) => {
-      let totalNumberOfPages2 = Math.round(filteredData.length / rows) - 1;
-      totalNumberOfPages2 = totalNumberOfPages2 <= 0 ? 0 : 1;
-      if (currentPage > totalNumberOfPages2) setCurrentPage(totalNumberOfPages2);
-      setRowsPerPage(rows);
+}
+
+// src/contexts/AuthContext.tsx
+function createAuthContext() {
+  return createContext5({});
+}
+function CreateAuthProvider({
+  api,
+  children,
+  sessionTokenName,
+  Provider
+}) {
+  const [user, setUser] = useState11();
+  const [status, setStatus] = useState11("unauthenticated");
+  const { createAlert } = useAlert();
+  const signIn = useCallback8(
+    async ({ email, password }) => {
+      setStatus("loading");
+      try {
+        const response = await api.post("/auth/login", {
+          email,
+          password
+        });
+        const { token } = response.data;
+        api.defaults.headers.common.Authorization = `Bearer ${token}`;
+        const { data } = await api.get("/auth/me");
+        setUser(data);
+        setStatus("autenticated");
+        return true;
+      } catch (error) {
+        createAlert(error?.response?.data?.error, "error");
+        setStatus("unauthenticated");
+        throw error;
+      }
     },
-    [currentPage]
+    [createAlert, api]
   );
-  const orderedData = useMemo3(() => {
-    if (sortedBy.length === 0) return defaultData;
-    const newData = defaultData.slice(0);
-    const sortedData = sortData(newData);
-    return sortedData;
-  }, [defaultData, sortData, sortedBy]);
-  const filteredData = useMemo3(() => {
-    let newData = orderedData.slice(0);
-    if (search && search.value !== "") {
-      const searchBy = createSearch(search);
-      newData = newData.filter(searchBy);
+  const ClientSignOut = useCallback8(async () => {
+    await api.get("/auth/logout");
+    setUser(void 0);
+  }, [api]);
+  useEffect8(() => {
+    const token = parseCookies()[sessionTokenName];
+    if (token) {
+      setStatus("loading");
+      api.get("/auth/me").then((response) => {
+        setStatus("autenticated");
+        setUser(response.data);
+      }).catch(() => {
+        setStatus("unauthenticated");
+      });
     }
-    if (!filters) return newData;
-    const newFilter = createFilter(filters);
-    return newData.filter(newFilter.apply);
-  }, [orderedData, search, filters]);
-  const paginatedData = useMemo3(() => {
-    const startPage = currentPage * rowsPerPage;
-    const endPage = startPage + rowsPerPage;
-    return filteredData.slice(startPage, endPage);
-  }, [currentPage, rowsPerPage, filteredData]);
-  const totalNumberOfPages = Math.ceil(filteredData.length / rowsPerPage) - 1;
-  useEffect4(() => {
-    if (externalDefaultData) setDefaultData(externalDefaultData);
-  }, [externalDefaultData]);
-  return {
-    data: paginatedData,
-    orderedData,
-    filteredData,
-    defaultData,
-    sortedBy,
-    columns,
-    currentPage,
-    totalNumberOfPages: totalNumberOfPages < 0 ? 0 : totalNumberOfPages,
-    rowsPerPageOptions,
-    rowsPerPage,
-    set,
-    onSortBy,
-    onPageChange,
-    setRowsPerPage: onChangeRowsPerPage,
-    appendSort,
-    setSort,
-    clearSort
-  };
+  }, [api, sessionTokenName]);
+  return /* @__PURE__ */ React33.createElement(
+    Provider,
+    {
+      value: {
+        user,
+        signOut: ClientSignOut,
+        signIn,
+        status
+      }
+    },
+    children
+  );
 }
-var isNumberOrString = (value) => ["number", "string"].includes(typeof value);
-var concatenateKey = (key, prev) => {
-  if (!prev) return key;
-  return `${prev}.${key}`;
+
+// src/errors/HttpError.ts
+var HttpError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.message = message;
+    this.stack = `HttpError: ${message}`;
+    this.status = status;
+  }
+};
+
+// src/errors/DomainError.ts
+var DomainError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.message = message;
+    this.stack = `DomainError: ${message}`;
+  }
 };
-function searchKeysForValue(row, accKey, compare) {
-  if (typeof row === "undefined") return false;
-  const rowKeys = Object.keys(row);
-  let match = false;
-  for (const key of rowKeys) {
-    if (match) break;
-    const objValue = row[key];
-    if (!objValue) continue;
-    const concatenatedKey = concatenateKey(key, accKey);
-    if (Array.isArray(objValue)) {
-      match = objValue.some(
-        (obj) => isNumberOrString(obj) ? compare(concatenatedKey, obj) : searchKeysForValue(obj, concatenatedKey, compare)
-      );
-      continue;
-    }
-    if (typeof objValue === "object") {
-      match = searchKeysForValue(objValue, concatenatedKey, compare);
-      continue;
-    }
-    match = compare(concatenatedKey, row[key]);
+
+// src/helpers/apiHelper/index.ts
+var VALID_METHODS = [
+  "GET",
+  "HEAD",
+  "POST",
+  "PUT",
+  "DELETE",
+  "CONNECT",
+  "OPTIONS",
+  "TRACE",
+  "PATCH"
+];
+var _ApiHelper = class _ApiHelper {
+  async onFinally(_req, _res) {
   }
-  return match;
-}
-var normalize = (str) => str.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
-function createSearch(options) {
-  const searchValue = options.caseSensitive ? options.value : String(options.value).toLowerCase();
-  function getValue2(value) {
-    if (options.caseSensitive) return String(value);
-    return String(value).toLowerCase();
+  async onError(_req, _res, _error) {
   }
-  function compare(key, objValue) {
-    if (options.ignoredKeys) {
-      const isIgnoredKey = options.ignoredKeys.includes(key);
-      if (isIgnoredKey) return false;
+  constructor(props) {
+    this.public = props?.public ?? false;
+    this.middlewares = (props?.middlewares || []).reverse();
+    this.onFinally = props?.onFinally || (async () => {
+    });
+    this.onError = props?.onError || (async () => {
+    });
+  }
+  createMethods(methods) {
+    return async (req, res) => {
+      const currentMethod = methods[req.method] || methods.ALL;
+      const options = { public: this.public };
+      if (req.method === "OPTIONS") return res.status(200).end();
+      try {
+        if (!VALID_METHODS.includes(req.method))
+          throw new HttpError(405, "M\xE9todo inv\xE1lido");
+        if (!currentMethod) throw new HttpError(500, "M\xE9todo n\xE3o encontrado");
+        const methodWithMiddlewares = this.middlewares.reduce(
+          (acc, fn) => fn(acc, options),
+          currentMethod
+        );
+        return await methodWithMiddlewares(req, res, options);
+      } catch (error) {
+        if (error instanceof DomainError) return res.status(400).json(error.message);
+        if (error instanceof HttpError) return res.status(error.status).json(error.message);
+        this.onError(req, res, error);
+        throw error;
+      } finally {
+        await this.onFinally(req, res);
+      }
+    };
+  }
+  buildFactory(factory) {
+    const options = {
+      public: this.public
+    };
+    return async (req, res) => {
+      const methods = factory(req, res);
+      const handler = methods[req.method];
+      if (!handler) throw new HttpError(405, "M\xE9todo inv\xE1lido");
+      const methodWithMiddlewares = this.middlewares.reduce((acc, fn) => {
+        return fn(acc, options);
+      }, handler);
+      return await methodWithMiddlewares(req, res, options);
+    };
+  }
+  static build(factory, options) {
+    const helper = new _ApiHelper({
+      ...options
+    }).buildFactory(factory);
+    return helper;
+  }
+  static parse(body, parser) {
+    try {
+      const object = parser.parse(body);
+      return object;
+    } catch (error) {
+      throw new HttpError(400, {
+        code: "invalid.body",
+        error: "Dados inv\xE1lidos",
+        details: error
+      });
     }
-    const value = getValue2(objValue);
-    if (options.exact) return value === searchValue;
-    if (options.ignoreAccentMark) return normalize(value).includes(normalize(searchValue));
-    return value.includes(searchValue);
   }
-  return (row) => {
-    const match = searchKeysForValue(row, "", compare);
-    return match;
-  };
-}
+  /** @deprecated Use {@Link ApiHelper.build} instead. */
+  static create({ onFinally }) {
+    return new _ApiHelper({
+      onFinally
+    });
+  }
+};
+/** @deprecated Use {@link ApiHelper.parser} instead. */
+_ApiHelper.parserErrorWrapper = _ApiHelper.parse;
+var ApiHelper = _ApiHelper;
 
-// src/hooks/useAsyncGrid.ts
-import { useCallback as useCallback4, useEffect as useEffect5, useState as useState8 } from "react";
-function useAsyncGrid({
-  columns,
-  filters = [],
-  search,
-  rowsPerPageOptions = [30, 60, 100],
-  onRequest,
-  axiosInstance,
-  url,
-  defaultData: externalDefaultData,
-  defaultCurrentPage,
-  defaultSortedBy
+// src/helpers/authHelper.ts
+import { serialize as serialize2 } from "cookie";
+import jwt from "jsonwebtoken";
+import { randomUUID } from "crypto";
+function decodeSessionToken({
+  req,
+  res,
+  sessionTokenName,
+  validate
 }) {
-  const [defaultData, setDefaultData] = useState8(externalDefaultData || []);
-  const [sortedBy, setSortedBy] = useState8(
-    defaultSortedBy || []
-  );
-  const [totalNumberOfItems, setTotalNumberOfItems] = useState8(0);
-  const [isLoading, setIsLoading] = useState8(false);
-  const [currentPage, setCurrentPage] = useState8(defaultCurrentPage || 0);
-  const [rowsPerPage, setRowsPerPage] = useState8(rowsPerPageOptions[0]);
-  const totalNumberOfPages = Math.ceil(totalNumberOfItems / rowsPerPage) - 1;
-  const toggleSortedDirection = useCallback4(
-    (direction) => {
-      if (direction === "asc") return "desc";
-      return "asc";
-    },
-    []
-  );
-  const setSort = useCallback4((prop, direction) => {
-    setSortedBy((prev) => [...prev, { prop, direction }]);
-  }, []);
-  const onSortBy = useCallback4(
-    async (prop) => {
-      if (!prop) return;
-      let finalArr = [];
-      const currentSorted = sortedBy.find((p) => p.prop === prop);
-      if (currentSorted) {
-        if (currentSorted.direction === "asc") {
-          finalArr = sortedBy.filter((p) => p.prop !== prop);
-        } else {
-          finalArr = sortedBy.map((p) => {
-            if (p.prop !== prop) return p;
-            return {
-              prop: p.prop,
-              direction: toggleSortedDirection(p.direction)
-            };
-          });
-        }
-      } else {
-        finalArr = [...sortedBy, { prop, direction: "desc" }];
+  const token = req.headers.authorization?.split(" ")[1] || req.cookies[sessionTokenName];
+  if (!token) {
+    res.status(401).json({ error: "Token inv\xE1lido", code: "token.invalid" });
+    return true;
+  }
+  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;
+  } catch (_) {
+    res.status(401).json({ error: "Token inv\xE1lido", code: "token.expired" });
+    return true;
+  }
+}
+var AuthHelper = class {
+  constructor({
+    cookies,
+    oauth,
+    tokenExpTimeInSeconds,
+    onLogin,
+    onValidateRefreshToken,
+    onInvalidateRefreshToken,
+    onCreateRefreshToken,
+    onGetUserData
+  }) {
+    this.generateJwtAndRefreshToken = async (userId, payload = {}) => {
+      const token = jwt.sign(payload, process.env.JWT_SECRET, {
+        subject: String(userId),
+        expiresIn: this.tokenExpTimeInSeconds || 60 * 15
+        // 15 minutos
+      });
+      const uniqueToken = randomUUID();
+      await this.onCreateRefreshToken(userId, uniqueToken);
+      return {
+        token,
+        refreshToken: uniqueToken
+      };
+    };
+    this.invalidateCookies = (res) => {
+      return res.setHeader("Set-Cookie", [
+        serialize2(this.cookies.sessionToken, "", {
+          maxAge: -1,
+          path: "/"
+        }),
+        serialize2(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;
+  }
+  async handler(req, res) {
+    if (!req.url) return res.status(400).json({ error: "url not sent" });
+    if (req.url.endsWith("/login")) {
+      const loginResult = await this.onLogin(req.body);
+      if (loginResult.status === "success") {
+        const { refreshToken, token } = await 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 });
       }
-      await updateGridContent({
-        page: currentPage,
-        sortedBy: finalArr,
-        rowsPerPage
+      throw new HttpError(400, loginResult.response);
+    }
+    if (req.url.endsWith("/logout")) {
+      this.invalidateCookies(res).end();
+    }
+    if (req.url.endsWith("/refresh")) {
+      const error = decodeSessionToken({
+        req,
+        res,
+        sessionTokenName: this.cookies.sessionToken,
+        validate: false
       });
-    },
-    [sortedBy, toggleSortedDirection, rowsPerPage, currentPage]
-  );
-  const set = useCallback4((data) => {
-    setDefaultData(data);
-  }, []);
-  const baseRequest = useCallback4(
-    async ({
-      page,
-      search: search2,
-      filters: filters2,
-      sortedBy: sortedBy2,
-      rowsPerPage: rowsPerPage2
-    }) => {
-      if (!axiosInstance) throw new Error("Axios instance not provided");
-      try {
-        const params = new URLSearchParams({
-          page: String(page),
-          rowsPerPage: String(rowsPerPage2),
-          searchText: search2?.value || "",
-          sort: sortedBy2.map(({ prop, direction }) => `${prop}:${direction}`).join(","),
-          filters: filters2.map(
-            (filter) => `${filter.prop}:${filter.compareType}:${filter.value}`
-          ).join(",")
+      if (error) return;
+      const userId = String(req.user);
+      const refreshToken = parseCookies({ req })[this.cookies.refreshToken];
+      if (!refreshToken) {
+        this.invalidateCookies(res);
+        return res.status(400).json({
+          error: "Refresh Token inv\xE1lido"
         });
-        const pathWithParams = `${url}?${params.toString()}`;
-        const { data } = await axiosInstance.get(pathWithParams);
-        setTotalNumberOfItems(data.totalNumberOfItems);
-        return data.rows;
-      } catch (_) {
-        return [];
-      }
-    },
-    [axiosInstance, url]
-  );
-  const updateGridContent = useCallback4(
-    async ({
-      page,
-      sortedBy: sortedBy2,
-      rowsPerPage: rowsPerPage2
-    }) => {
-      setIsLoading(true);
-      try {
-        const props = {
-          page,
-          rowsPerPage: rowsPerPage2,
-          sortedBy: sortedBy2,
-          search,
-          filters
-        };
-        const result = !onRequest ? await baseRequest(props) : await onRequest(props);
-        setSortedBy(sortedBy2);
-        setRowsPerPage(rowsPerPage2);
-        set(result);
-        setCurrentPage(page);
-      } finally {
-        setIsLoading(false);
       }
-    },
-    [set, search, filters, onRequest, baseRequest]
-  );
-  const onPageChange = useCallback4(
-    (pageNumber) => {
-      if (pageNumber < 0) return;
-      if (pageNumber > totalNumberOfPages) return;
-      updateGridContent({ page: pageNumber, sortedBy, rowsPerPage });
-    },
-    [updateGridContent, totalNumberOfPages, sortedBy, rowsPerPage]
-  );
-  const onChangeRowsPerPage = useCallback4(
-    (rows) => {
-      let totalNumberOfPages2 = Math.round(totalNumberOfItems / rows) - 1;
-      totalNumberOfPages2 = totalNumberOfPages2 <= 0 ? 0 : 1;
-      if (currentPage > totalNumberOfPages2)
-        updateGridContent({
-          page: totalNumberOfPages2,
-          sortedBy,
-          rowsPerPage: rows
+      const isValidRefreshToken = await this.onValidateRefreshToken(
+        userId,
+        refreshToken
+      );
+      if (!isValidRefreshToken) {
+        this.invalidateCookies(res);
+        return res.status(400).json({
+          error: "Refresh Token inv\xE1lido"
         });
-      updateGridContent({
-        page: currentPage,
-        sortedBy,
-        rowsPerPage: rows
+      }
+      await this.onInvalidateRefreshToken(userId, refreshToken);
+      const { token, refreshToken: newRefreshToken } = await this.generateJwtAndRefreshToken(userId, {});
+      setCookie({ res }, this.cookies.sessionToken, token, {
+        secure: true,
+        maxAge: 60 * 60 * 24 * 30,
+        // 30 days
+        path: "/",
+        sameSite: true
       });
-    },
-    [updateGridContent, totalNumberOfItems, sortedBy, currentPage]
-  );
-  const displayData = defaultData;
-  useEffect5(() => {
-    updateGridContent({ page: 0, sortedBy: [], rowsPerPage });
-  }, [updateGridContent, rowsPerPage]);
-  return {
-    data: displayData,
-    set,
-    onSortBy,
-    sortedBy,
-    defaultData,
-    columns,
-    currentPage,
-    totalNumberOfPages: totalNumberOfPages < 0 ? 0 : totalNumberOfPages,
-    onPageChange,
-    setRowsPerPage: onChangeRowsPerPage,
-    rowsPerPageOptions,
-    rowsPerPage,
-    setSort,
-    isLoading,
-    setIsLoading
-  };
-}
-
-// src/hooks/useEvent.ts
-import { useEffect as useEffect6 } from "react";
-function useEvent(event, handler, passive = false) {
-  useEffect6(() => {
-    window.addEventListener(event, handler, passive);
-    return function cleanup() {
-      window.removeEventListener(event, handler);
-    };
-  });
-}
-
-// src/hooks/useLoading.ts
-import { useCallback as useCallback5, useState as useState9 } from "react";
-function useLoading() {
-  const [state, setState] = useState9([]);
-  const isLoading = useCallback5((prop) => state.includes(prop), [state]);
-  const setLoading = useCallback5((prop, remove) => {
-    if (remove)
-      setState((prevState) => prevState.filter((state2) => state2 !== prop));
-    else setState((prevState) => [...prevState, prop]);
-  }, []);
-  return { isLoading, setLoading };
-}
-
-// src/hooks/useAlert.ts
-import { useContext as useContext3 } from "react";
-
-// src/contexts/AlertContext.tsx
-import React31, { useCallback as useCallback6 } from "react";
-import { createContext as createContext3, useState as useState10 } from "react";
-
-// src/components/Toast/index.tsx
-import React30 from "react";
-import { Alert, IconButton as IconButton5, Snackbar } from "@mui/material";
-import { MdClose as MdClose3 } from "react-icons/md";
-var Toast = ({ open, onClose, severity, message }) => {
-  return /* @__PURE__ */ React30.createElement(React30.Fragment, null, /* @__PURE__ */ React30.createElement(
-    Snackbar,
-    {
-      open,
-      autoHideDuration: 6e3,
-      onClose,
-      anchorOrigin: { vertical: "top", horizontal: "right" },
-      sx: { zIndex: 99999999 }
-    },
-    /* @__PURE__ */ React30.createElement(
-      Alert,
-      {
-        severity,
-        elevation: 2,
-        action: /* @__PURE__ */ React30.createElement(
-          IconButton5,
-          {
-            "aria-label": "close",
-            color: "inherit",
-            size: "small",
-            onClick: onClose
-          },
-          /* @__PURE__ */ React30.createElement(MdClose3, { fontSize: "inherit" })
-        )
-      },
-      message
-    )
-  ));
-};
-
-// src/contexts/AlertContext.tsx
-var AlertContext = createContext3({});
-var AlertProvider = ({ children }) => {
-  const [severity, setSeverity] = useState10("info");
-  const [message, setMessage] = useState10("");
-  const [isVisible, setIsVisible] = useState10(false);
-  const createAlert = useCallback6(
-    (newMessage, severity2) => {
-      setMessage(newMessage);
-      setSeverity(severity2);
-      setIsVisible(true);
-    },
-    []
-  );
-  const onCloseToast = useCallback6(() => {
-    setIsVisible(false);
-  }, []);
-  return /* @__PURE__ */ React31.createElement(AlertContext.Provider, { value: { createAlert } }, children, /* @__PURE__ */ React31.createElement(
-    Toast,
-    {
-      open: isVisible,
-      onClose: onCloseToast,
-      severity,
-      message
+      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")) {
+      const error = decodeSessionToken({
+        req,
+        res,
+        sessionTokenName: this.cookies.sessionToken,
+        validate: true
+      });
+      if (error) return;
+      if (!req.user)
+        return res.status(400).json({ error: "Usu\xE1rio n\xE3o encontrado" });
+      const userData = await this.onGetUserData(req.user);
+      if (!userData)
+        return res.status(400).json({ error: "Usu\xE1rio n\xE3o encontrado" });
+      return res.json(userData);
     }
-  ));
-};
-
-// src/hooks/useAlert.ts
-var useAlert = () => {
-  return useContext3(AlertContext);
-};
-
-// src/hooks/useFormHelper.ts
-import { useCallback as useCallback7, useContext as useContext4, useEffect as useEffect7, useRef as useRef4 } from "react";
-
-// src/contexts/FormHelperProvider.tsx
-import React32 from "react";
-import { createContext as createContext4 } from "react";
-var FormHelperContext = createContext4({});
-var FormHelperProvider = ({ formatErrorMessage, api, children }) => {
-  return /* @__PURE__ */ React32.createElement(FormHelperContext.Provider, { value: { formatErrorMessage, api } }, children);
-};
-
-// src/hooks/useFormHelper.ts
-function useFormHelper() {
-  const alertProps = useAlert();
-  const loadingProps = useLoading();
-  const { api, formatErrorMessage } = useContext4(FormHelperContext);
-  const { createAlert } = alertProps;
-  const { setLoading } = loadingProps;
-  const sourceRef = useRef4(new AbortController());
-  const onSubmitWrapper = useCallback7(
-    (fn, { name }) => {
-      return async (fields, methods) => {
-        const LOADING_NAME = name;
-        setLoading(LOADING_NAME);
-        try {
-          await fn(fields, methods);
-        } catch (error) {
-          errorHandler(error, methods.setErrors);
-        } finally {
-          setLoading(LOADING_NAME, true);
-        }
-      };
-    },
-    [setLoading]
-  );
-  const onRequestWrapper = useCallback7(
-    (fn, { name }) => {
-      return async (...params) => {
-        const LOADING_NAME = name;
-        setLoading(LOADING_NAME);
-        api.interceptors.request.use(
-          (config) => {
-            if (!config.signal && sourceRef.current && config.method === "get") {
-              config.signal = sourceRef.current.signal;
-            }
-            return config;
-          },
-          (error) => {
-            return Promise.reject(error);
-          }
-        );
-        try {
-          const response = await fn(...params);
-          return response;
-        } catch (error) {
-          errorHandler(error);
-        } finally {
-          setLoading(LOADING_NAME, true);
-        }
+    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"
       };
-    },
-    [setLoading, api]
-  );
-  const errorHandler = useCallback7(
-    (error, callback) => {
-      if (error?.message === "cancel.navigation") return;
-      if (callback) {
-        if (error.response.data.code === "invalid.body") {
-          const errors = error.response.data.details.issues;
-          const currentErrors = errors.reduce((acc, item) => {
-            acc[item.path.join(".")] = item.message;
-            return acc;
-          }, {});
-          callback(currentErrors);
-        }
-      }
-      createAlert(formatErrorMessage(error), "error");
-    },
-    [formatErrorMessage, createAlert]
-  );
-  useEffect7(() => {
-    return () => {
-      sourceRef.current.abort();
-      sourceRef.current = new AbortController();
+      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" });
+  }
+  async oauthSignInCallback(code) {
+    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
     };
-  }, []);
-  return {
-    ...alertProps,
-    ...loadingProps,
-    onSubmitWrapper,
-    onRequestWrapper
-  };
-}
-
-// src/contexts/AuthContext.tsx
-import React33, { useCallback as useCallback8 } from "react";
-import {
-  createContext as createContext5,
-  useEffect as useEffect8,
-  useState as useState11
-} from "react";
-function createAuthContext() {
-  return createContext5({});
-}
-function CreateAuthProvider({
-  api,
-  children,
-  sessionTokenName,
-  Provider
-}) {
-  const [user, setUser] = useState11();
-  const [status, setStatus] = useState11("unauthenticated");
-  const { createAlert } = useAlert();
-  const signIn = useCallback8(
-    async ({ email, password }) => {
-      setStatus("loading");
+    const response = await 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 = await response.json();
+    const decodedToken = jwt.decode(data.access_token);
+    const email = decodedToken.upn;
+    const fullName = `${decodedToken?.given_name} ${decodedToken?.family_name}`;
+    return { decodedToken, email, fullName };
+  }
+  createOauthCallbackGetServerSideProps({
+    onSuccessDestination,
+    onFailedDestination
+  }) {
+    return async (ctx) => {
+      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 response = await api.post("/auth/login", {
+        const { fullName, email } = await this.oauthSignInCallback(code);
+        const userExists = await this.onGetUserData(email);
+        if (!userExists && !this.oauth.onCreateUser)
+          throw new Error("User does not exists");
+        if (!userExists && this.oauth.onCreateUser) {
+          await this.oauth.onCreateUser({ fullname: fullName, email });
+        }
+        const { token, refreshToken } = await this.generateJwtAndRefreshToken(
           email,
-          password
+          {}
+        );
+        setCookie(ctx, this.cookies.sessionToken, token, {
+          secure: true,
+          maxAge: 60 * 60 * 24 * 30,
+          // 30 days
+          path: "/"
         });
-        const { token } = response.data;
-        api.defaults.headers.common.Authorization = `Bearer ${token}`;
-        const { data } = await api.get("/auth/me");
-        setUser(data);
-        setStatus("autenticated");
-        return true;
+        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) {
-        createAlert(error?.response?.data?.error, "error");
-        setStatus("unauthenticated");
-        throw error;
-      }
-    },
-    [createAlert, api]
-  );
-  const ClientSignOut = useCallback8(async () => {
-    await api.get("/auth/logout");
-    setUser(void 0);
-  }, [api]);
-  useEffect8(() => {
-    const token = parseCookies()[sessionTokenName];
-    if (token) {
-      setStatus("loading");
-      api.get("/auth/me").then((response) => {
-        setStatus("autenticated");
-        setUser(response.data);
-      }).catch(() => {
-        setStatus("unauthenticated");
-      });
-    }
-  }, [api, sessionTokenName]);
-  return /* @__PURE__ */ React33.createElement(
-    Provider,
-    {
-      value: {
-        user,
-        signOut: ClientSignOut,
-        signIn,
-        status
+        return {
+          props: {
+            error: JSON.stringify(error)
+          }
+        };
       }
-    },
-    children
-  );
-}
+    };
+  }
+};
 export {
   AlertContext,
   AlertProvider,