npm-pkg-hook 1.3.4 → 1.3.6

package/package.json

@@ -43,5 +43,5 @@
     "rm": "rm -rf node_modules package-lock.json && npm i",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "version": "1.3.4"
+  "version": "1.3.6"
 }

package/src/hooks/getGlobalSession/index.js

@@ -14,28 +14,36 @@ const ENCRYPTION_KEY = generateEncryptionKey(
 const IV_LENGTH = 16 // Para AES, este siempre debe ser 16
 
 export const encryptSession = (text) => {
-  const iv = crypto.randomBytes(IV_LENGTH)
-  const cipher = crypto.createCipheriv(
-    'aes-256-cbc',
-    Buffer.from(ENCRYPTION_KEY),
-    iv
-  )
-  let encrypted = cipher.update(text)
-  encrypted = Buffer.concat([encrypted, cipher.final()])
-  return iv.toString('hex') + ':' + encrypted.toString('hex')
+  try {
+    const iv = crypto.randomBytes(IV_LENGTH)
+    const cipher = crypto.createCipheriv(
+      'aes-256-cbc',
+      Buffer.from(ENCRYPTION_KEY),
+      iv
+    )
+    let encrypted = cipher.update(text)
+    encrypted = Buffer.concat([encrypted, cipher.final()])
+    return iv.toString('hex') + ':' + encrypted.toString('hex')
+  } catch (error) {
+    return null
+  }
 }
 
 export const decryptSession = (text) => {
-  if (!text) return
-  const textParts = text.split(':')
-  const iv = Buffer.from(textParts.shift(), 'hex')
-  const encryptedText = Buffer.from(textParts.join(':'), 'hex')
-  const decipher = crypto.createDecipheriv(
-    'aes-256-cbc',
-    Buffer.from(ENCRYPTION_KEY),
-    iv
-  )
-  let decrypted = decipher.update(encryptedText)
-  decrypted = Buffer.concat([decrypted, decipher.final()])
-  return decrypted.toString()
+  try {
+    if (!text) return
+    const textParts = text.split(':')
+    const iv = Buffer.from(textParts.shift(), 'hex')
+    const encryptedText = Buffer.from(textParts.join(':'), 'hex')
+    const decipher = crypto.createDecipheriv(
+      'aes-256-cbc',
+      Buffer.from(ENCRYPTION_KEY),
+      iv
+    )
+    let decrypted = decipher.update(encryptedText)
+    decrypted = Buffer.concat([decrypted, decipher.final()])
+    return decrypted.toString()
+  } catch (error) {
+    return null
+  }
 }

package/src/hooks/useGetStoreCookie/index.js

@@ -6,7 +6,7 @@ export const useGetStoreCookie = () => {
 
   useEffect(() => {
     const getCookieValue = () => {
-      const cookieValue = Cookies.get('vp.store');
+      const cookieValue = Cookies.get(process.env.SESSION_NAME);
       console.log('Cookie Value:', cookieValue);
 
       if (cookieValue) {

package/src/hooks/useLogout/helpers/BroadcastChannel.js

@@ -0,0 +1,32 @@
+function BroadcastChannel(name = "nextauth.message") {
+    return {
+      receive: function (onReceive) {
+        const handler = function (event) {
+          if (event.key !== name) return;
+          const message = JSON.parse(event.newValue ?? "{}");
+          if (message?.event !== "session" || !message?.data) return;
+          onReceive(message);
+        };
+        window.addEventListener("storage", handler);
+        return function () {
+          window.removeEventListener("storage", handler);
+        };
+      },
+      post: function (message) {
+        if (typeof window === "undefined") return;
+        try {
+          localStorage.setItem(
+            name,
+            JSON.stringify({ ...message, timestamp: now() })
+          );
+        } catch {
+          // The localStorage API isn't always available.
+          // It won't work in private mode prior to Safari 11 for example.
+          // Notifications are simply dropped if an error is encountered.
+        }
+      },
+    };
+  }
+  
+  export { BroadcastChannel };
+  

package/src/hooks/useLogout/helpers/apiBaseUrl.js

@@ -0,0 +1,8 @@
+export function apiBaseUrl(__NEXTAUTH) {
+    if (typeof window === "undefined") {
+      // Return absolute path when called server side
+      return `${__NEXTAUTH.baseUrlServer}${__NEXTAUTH.basePathServer}`
+    }
+    // Return relative path when called client side
+    return __NEXTAUTH.basePath
+  }

package/src/hooks/useLogout/helpers/fetchData.js

@@ -0,0 +1,29 @@
+import { apiBaseUrl } from "./apiBaseUrl";
+
+async function fetchData(path, __NEXTAUTH, logger, { ctx, req } = {}) {
+    const url = `${apiBaseUrl(__NEXTAUTH)}/${path}`;
+    try {
+      const options = {
+        headers: {
+          "Content-Type": "application/json",
+          ...(req?.headers?.cookie ? { cookie: req.headers.cookie } : {}),
+        },
+      };
+
+      if (req?.body) {
+        options.body = JSON.stringify(req.body);
+        options.method = "POST";
+      }
+
+      const res = await fetch(url, options);
+      const data = await res.json();
+      if (!res.ok) throw data;
+      return Object.keys(data).length > 0 ? data : null; // Return null if data is empty
+    } catch (error) {
+      logger.error("CLIENT_FETCH_ERROR", { error, url });
+      return null;
+    }
+  }
+  
+  export { fetchData };
+  

package/src/hooks/useLogout/helpers/getCsrfToken.js

@@ -0,0 +1,30 @@
+import { fetchData } from "./fetchData"
+import _logger, { proxyLogger } from "./logger"
+import { parseUrl } from "./parseUrl";
+
+const __NEXTAUTH = {
+    baseUrl: parseUrl(process.env.NEXTAUTH_URL || process.env.VERCEL_URL).origin,
+    basePath: parseUrl(process.env.NEXTAUTH_URL).path,
+    baseUrlServer: parseUrl(
+      process.env.NEXTAUTH_URL_INTERNAL ||
+        process.env.NEXTAUTH_URL ||
+        process.env.VERCEL_URL
+    ).origin,
+    basePathServer: parseUrl(
+      process.env.NEXTAUTH_URL_INTERNAL || process.env.NEXTAUTH_URL
+    ).path,
+    _lastSync: 0,
+    _session: undefined,
+    _getSession: () => {},
+  };
+const logger = proxyLogger(_logger, __NEXTAUTH.basePath)
+
+export async function getCsrfToken(params) {
+    const response = await fetchData(
+      "csrf",
+      __NEXTAUTH,
+      logger,
+      params
+    )
+    return response?.csrfToken
+  }

package/src/hooks/useLogout/helpers/index.js

@@ -0,0 +1,54 @@
+import { apiBaseUrl } from "./apiBaseUrl";
+import { getCsrfToken } from "./getCsrfToken";
+import { parseUrl } from "./parseUrl";
+import { BroadcastChannel } from "./BroadcastChannel";
+
+const broadcast = BroadcastChannel()
+
+export const __NEXTAUTH = {
+    baseUrl: parseUrl(process.env.NEXTAUTH_URL || process.env.VERCEL_URL).origin,
+    basePath: parseUrl(process.env.NEXTAUTH_URL).path,
+    baseUrlServer: parseUrl(
+      process.env.NEXTAUTH_URL_INTERNAL ||
+        process.env.NEXTAUTH_URL ||
+        process.env.VERCEL_URL
+    ).origin,
+    basePathServer: parseUrl(
+      process.env.NEXTAUTH_URL_INTERNAL || process.env.NEXTAUTH_URL
+    ).path,
+    _lastSync: 0,
+    _session: undefined,
+    _getSession: () => {},
+  };
+
+  export async function signOutAuth(options) {
+    const { callbackUrl = window.location.href } = options ?? {}
+    const baseUrl = apiBaseUrl(__NEXTAUTH)
+    const fetchOptions = {
+      method: "post",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+      },
+      // @ts-expect-error
+      body: new URLSearchParams({
+        csrfToken: await getCsrfToken(),
+        callbackUrl,
+        json: true,
+      }),
+    }
+    const res = await fetch(`${baseUrl}/signout`, fetchOptions)
+    const data = await res.json()
+
+    broadcast.post({ event: "session", data: { trigger: "signout" } })
+
+    if (options?.redirect ?? true) {
+      const url = data.url ?? callbackUrl
+      window.location.href = url
+      // If url contains a hash, the browser does not reload the page. We reload manually
+      if (url.includes("#")) window.location.reload()
+      // @ts-expect-error
+      return
+    }
+    await __NEXTAUTH._getSession({ event: "storage" })
+    return data
+  }

package/src/hooks/useLogout/helpers/logger.js

@@ -0,0 +1,72 @@
+function formatError(o) {
+  if (hasErrorProperty(o)) {
+    o.error = formatError(o.error);
+    o.message = o.message ?? o.error.message;
+  }
+  return o;
+}
+
+function hasErrorProperty(x) {
+  return !!(x?.error);
+}
+
+const _logger = {
+  error(code, metadata) {
+    metadata = formatError(metadata);
+    console.error(
+      `[next-auth][error][${code}]`,
+      `\nhttps://next-auth.js.org/errors#${code.toLowerCase()}`,
+      metadata.message,
+      metadata
+    );
+  },
+  warn(code) {
+    console.warn(
+      `[next-auth][warn][${code}]`,
+      `\nhttps://next-auth.js.org/warnings#${code.toLowerCase()}`
+    );
+  },
+  debug(code, metadata) {
+    console.log(`[next-auth][debug][${code}]`, metadata);
+  },
+};
+
+
+export function setLogger(newLogger = {}, debug) {
+  if (!debug) _logger.debug = () => {};
+
+  if (newLogger.error) _logger.error = newLogger.error;
+  if (newLogger.warn) _logger.warn = newLogger.warn;
+  if (newLogger.debug) _logger.debug = newLogger.debug;
+}
+
+export function proxyLogger(logger = _logger, basePath) {
+  try {
+    if (typeof window === "undefined") {
+      return logger;
+    }
+
+    const clientLogger = {};
+    for (const level in logger) {
+      clientLogger[level] = (code, metadata) => {
+        _logger[level](code, metadata);
+
+        if (level === "error") {
+          metadata = formatError(metadata);
+        }
+        metadata.client = true;
+        const url = `${basePath}/_log`;
+        const body = new URLSearchParams({ level, code, ...metadata });
+        if (navigator.sendBeacon) {
+          return navigator.sendBeacon(url, body);
+        }
+        return fetch(url, { method: "POST", body, keepalive: true });
+      };
+    }
+    return clientLogger;
+  } catch {
+    return _logger;
+  }
+}
+export { _logger as default };
+

package/src/hooks/useLogout/helpers/parseUrl.js

@@ -0,0 +1,36 @@
+/** Interface for the internal URL structure */
+const InternalUrl = {
+    origin: 'http://localhost:3000',
+    host: 'localhost:3000',
+    path: '/api/auth',
+    base: 'http://localhost:3000/api/auth',
+    toString: function() {
+      return this.base;
+    },
+  };
+
+  /** Function to parse a URL-like object for server-side requests/redirects */
+  function parseUrl(url) {
+    const defaultUrl = new URL('http://localhost:3000/api/auth');
+
+    if (url && !url.startsWith('http')) {
+      url = `https://${url}`;
+    }
+
+    const _url = new URL(url || defaultUrl);
+    const path = (_url.pathname === '/' ? defaultUrl.pathname : _url.pathname).replace(/\/$/, '');
+
+    const base = `${_url.origin}${path}`;
+
+    return {
+      origin: _url.origin,
+      host: _url.host,
+      path,
+      base,
+      toString: function() {
+        return base;
+      },
+    };
+  }
+
+  export { InternalUrl, parseUrl };

package/src/hooks/useLogout/index.js

@@ -1,12 +1,12 @@
 import { useApolloClient } from '@apollo/client'
 import { useState } from 'react'
-import { useRouter } from 'next/router'
 import { Cookies } from '../../cookies'
+import { signOutAuth } from './helpers'
+export { signOutAuth } from './helpers'
 
 export const useLogout = ({ setAlertBox = () => { } } = {}) => {
   const [loading, setLoading] = useState(false)
   const [error, setError] = useState(false)
-  const router = useRouter()
   const client = useApolloClient()
 
   const onClickLogout = async () => {
@@ -15,23 +15,18 @@ export const useLogout = ({ setAlertBox = () => { } } = {}) => {
       .fetch(`${process.env.URL_BASE}/api/auth/logout/`, {})
       .then(res => {
         if (res) {
-          localStorage.removeItem('session')
-          localStorage.removeItem('usuario')
-          localStorage.removeItem('location')
-          localStorage.removeItem('sessionGoogle')
-          localStorage.removeItem('namefood')
-          localStorage.removeItem('longitude')
-          localStorage.removeItem('latitude')
-          localStorage.removeItem('userlogin')
-          localStorage.removeItem('restaurant')
-          Cookies.remove('vp.store')
-          Cookies.remove('app.cart.sales')
+          Cookies.remove(process.env.SESSION_NAME)
+          Cookies.remove(process.env.LOCAL_SALES_STORE)
           Cookies.remove('restaurant')
+          Cookies.remove('usuario')
+          Cookies.remove('session')
           client?.clearStore()
-          router.replace('/entrar')
           setLoading(false)
+          console.log('Borrado todo')
+
         }
       })
+      signOutAuth({ redirect: true, callbackUrl: '/' })
       .catch(() => {
         setError(true)
         setAlertBox({ message: 'Ocurrió un error al cerrar session' })

package/src/hooks/useSales/index.js

@@ -82,9 +82,11 @@ export const useSales = ({
   const [_, setFilteredList] = useState([])
   const [delivery, setDelivery] = useState(false)
   const [print, setPrint] = useState(false)
+  const [errors, setErrors] = useState({})
   const [values, setValues] = useState({
     comment: '',
     change: '',
+    cliId: '',
     valueDelivery: ''
   })
   const [dataStore] = useStore()
@@ -185,8 +187,13 @@ export const useSales = ({
   const handleChangeFilter = (e) => {
     return setSearch(e.target.value)
   }
-  const handleChange = (e) => {
-    return setValues({ ...values, [e.target.name]: e.target.value })
+  const handleChange = (e, error) => {
+    const { name, value } = e.target;
+    setErrors({ ...errors, [e.target.name]: error })
+    setValues((prevValues) => ({
+      ...prevValues,
+      [name]: value,
+    }));
   }
   const onChangeInput = (e) => {
     return setValuesDates({ ...valuesDates, [e.target.name]: e.target.value })
@@ -816,29 +823,35 @@ export const useSales = ({
   const client = useApolloClient()
   const { getOnePedidoStore } = useGetSale()
   const handleSubmit = () => {
-    if (!values?.cliId) {
+
+    if (errors?.change  || errors?.valueDelivery) {
       return sendNotification({
-        title: 'Error',
-        backgroundColor: 'error',
-        description: 'Elije primero un cliente'
+        title: 'error',
+        backgroundColor: 'warning',
+        description: 'Completa los campos requeridos'
       })
     }
     setLoadingSale(true)
     const code = RandomCode(10)
     setCode(code)
-    const changeValue = values.change ? convertToIntegerOrFloat(values.change) : null;
-
+    function convertirAEntero(cadena) {
+      if (typeof cadena === 'string') {
+        const numeroEntero = parseInt(cadena?.replace('.', ''));
+        return numeroEntero
+      }
+      return cadena ||  0
+    }
     return registerSalesStore({
       variables: {
         input: finalArrayProduct || [],
         id: values?.cliId,
         pCodeRef: code,
-        change: changeValue,
-        valueDelivery: convertToIntegerOrFloat(values.valueDelivery),
+        change: convertirAEntero(values.change),
+        valueDelivery: convertirAEntero(values.valueDelivery),
         payMethodPState: data.payMethodPState,
         pickUp: 1,
         discount: discount.discount || 0,
-        totalProductsPrice: convertToIntegerOrFloat(totalProductsPrice) || 0
+        totalProductsPrice: convertirAEntero(totalProductsPrice) || 0
       }
     })
       .then((responseRegisterR) => {
@@ -1056,6 +1069,7 @@ export const useSales = ({
     disabledItems,
     setCheckedItems,
     handleChangeCheck,
+    errors,
     handleUpdateAllExtra,
     dispatch,
     handleComment,
@@ -1064,6 +1078,7 @@ export const useSales = ({
     handleProduct,
     handleChange,
     setOpenCurrentSale,
+    setErrors,
     onChangeInput,
     handleRemoveValue,
     applyDiscount,

package/src/hooks/useSetSession/index.js

@@ -2,26 +2,35 @@ import { Cookies } from '../../cookies';
 import { getCurrentDomain } from '../../utils';
 
 export const useSetSession = () => {
-  const domain = getCurrentDomain()
-
   const handleSession = async (props) => {
     try {
-      const { cookie } = props;
-      if (!Array.isArray(cookie)) {
+      const { cookies } = props;
+      let domain = getCurrentDomain();
+
+      // Si estás en entorno local, usa 'localhost' como dominio
+      if (domain === 'localhost') {
+        domain = undefined; // Esto permitirá la cookie en 'localhost'
+      }
+
+      if (!Array.isArray(cookies)) {
         throw new Error('Input cookies should be an array.');
       }
 
-      for (const { name, value } of cookie) {
+      for (const { name, value, domain: incomingDomain } of cookies) {
         if (value) {
           const expirationTime = new Date();
-          expirationTime.setTime(expirationTime.getTime() + 8 * 60 * 60 * 1000)
+          expirationTime.setTime(expirationTime.getTime() + 8 * 60 * 60 * 1000);
+
+          const formattedDomain = incomingDomain || domain;
+
           await Cookies.set(name, value, {
-            domain,
+            domain: formattedDomain,
             path: '/',
-            secure:  process.env.NODE_ENV === 'production',
-            sameSite: process.env.NODE_ENV === 'production' ? 'none' : 'lax', // Configura 'none' en producción
+            secure: process.env.NODE_ENV === 'production',
+            sameSite: process.env.NODE_ENV === 'production' ? 'none' : 'lax',
             expires: expirationTime
           });
+
         }
       }