npm-pkg-hook 1.12.4 → 1.12.8

package/src/hooks/useModules/helpers/{validateModules.js → validateModules.ts}

@@ -14,7 +14,7 @@ export const validateModules = (modules = [], permissions = {}) => {
 
     // Validate and filter subModules if they exist
     const validSubModules = module.subModules?.filter(subModule =>
-      permissions[subModule.view]?.includes('read')
+    {return permissions[subModule.view]?.includes('read')}
     ) || []
 
     // If the module or its subModules don't have read permission, exclude it

package/src/hooks/useModules/index.ts

@@ -0,0 +1,124 @@
+import { gql, useQuery } from '@apollo/client'
+
+import { validateModules } from './helpers/validateModules'
+
+/**
+ * GraphQL query to get modules and submodules
+ */
+const GET_MODULES = gql`
+  query GetModules {
+    modules {
+      mName
+      mId
+      mPath
+      mPriority
+      mIcon
+      view
+      subModules {
+        smId
+        smName
+        smPath
+        view
+        smIcon
+        smState
+      }
+    }
+  }
+`
+
+/**
+ * SubModule entity
+ */
+export interface SubModule {
+  smId: string
+  smName: string
+  smPath: string
+  smIcon?: string | null
+  smState?: boolean | null
+  view?: boolean | null
+}
+
+/**
+ * Module entity
+ */
+export interface Module {
+  mId: string
+  mName: string
+  mPath: string
+  mPriority?: number | null
+  mIcon?: string | null
+  view?: boolean | null
+  subModules?: SubModule[]
+}
+
+/**
+ * Permissions map
+ */
+export type Permissions = Record<string, boolean>
+
+/**
+ * User role structure
+ */
+export interface Role {
+  permissions?: Permissions
+}
+
+/**
+ * User data structure
+ */
+export interface UserData {
+  role?: Role
+}
+
+/**
+ * Hook params
+ */
+export interface UseModulesParams {
+  dataUser?: UserData
+  callback?: (modules: Module[]) => void
+}
+
+/**
+ * Hook return type
+ */
+export interface UseModulesResult {
+  loading: boolean
+  error?: Error
+  modules: Module[]
+}
+
+/**
+ * Custom hook to fetch and validate modules based on user permissions
+ *
+ * @param {UseModulesParams} params - Hook parameters
+ * @returns {UseModulesResult}
+ */
+export const useModules = ({
+  dataUser = {},
+  callback = () => {}
+}: UseModulesParams = {}): UseModulesResult => {
+  const permissions: Permissions = dataUser?.role?.permissions ?? {}
+
+  const { loading, error, data } = useQuery<{ modules: Module[] }>(GET_MODULES, {
+    fetchPolicy: 'cache-and-network',
+    onCompleted: (response) => {
+      if (Array.isArray(response?.modules)) {
+        callback(response.modules)
+      }
+    },
+    onError: (err) => {
+      console.error('Error fetching modules:', err)
+    }
+  })
+
+  const safeModules: Module[] = Array.isArray(data?.modules) ? data.modules : []
+
+  // cast to any to work around a too-narrow parameter type in the helper
+  const filteredModules: Module[] = validateModules(safeModules as any, permissions)
+
+  return {
+    loading,
+    error: error ?? undefined,
+    modules: filteredModules
+  }
+}

package/src/hooks/useMouse/index.ts

@@ -1,50 +1,55 @@
-import { useEffect, useRef, useState } from "react";
+import { useEffect, useRef, useState } from 'react'
 
+/**
+ *
+ * @param options
+ * @param options.resetOnExit
+ */
 export function useMouse(
   options: { resetOnExit } = { resetOnExit: false }
 ) {
-  const [position, setPosition] = useState({ x: 0, y: 0 });
+  const [position, setPosition] = useState({ x: 0, y: 0 })
 
-  const ref = useRef();
+  const ref = useRef()
 
   const setMousePosition = (event) => {
     if (ref.current) {
-      const rect = event.currentTarget.getBoundingClientRect();
+      const rect = event.currentTarget.getBoundingClientRect()
 
       const x = Math.max(
         0,
         Math.round(
           event.pageX - rect.left - (window.pageXOffset || window.scrollX)
         )
-      );
+      )
 
       const y = Math.max(
         0,
         Math.round(
           event.pageY - rect.top - (window.pageYOffset || window.scrollY)
         )
-      );
+      )
 
-      setPosition({ x, y });
+      setPosition({ x, y })
     } else {
-      setPosition({ x: event.clientX, y: event.clientY });
+      setPosition({ x: event.clientX, y: event.clientY })
     }
-  };
+  }
 
-  const resetMousePosition = () => setPosition({ x: 0, y: 0 });
+  const resetMousePosition = () => {return setPosition({ x: 0, y: 0 })}
 
   useEffect(() => {
-    const element = ref?.current ? ref.current : document;
-    element.addEventListener("mousemove", setMousePosition);
+    const element = ref?.current ? ref.current : document
+    element.addEventListener('mousemove', setMousePosition)
     if (options.resetOnExit)
-      element.addEventListener("mouseleave", resetMousePosition);
+      {element.addEventListener('mouseleave', resetMousePosition)}
 
     return () => {
-      element.removeEventListener("mousemove", setMousePosition);
+      element.removeEventListener('mousemove', setMousePosition)
       if (options.resetOnExit)
-        element.removeEventListener("mouseleave", resetMousePosition);
-    };
-  }, [ref.current]);
+        {element.removeEventListener('mouseleave', resetMousePosition)}
+    }
+  }, [ref.current])
 
-  return { ref, ...position };
+  return { ref, ...position }
 }

package/src/hooks/useOrderStatusTypes/useOrderStatusTypes/index.ts

@@ -110,7 +110,7 @@ export interface UseOrderStatusTypesOptions {
 }
 
 export const useOrderStatusTypes = ({
-  callback = () => undefined
+  callback = () => {return undefined}
 }: UseOrderStatusTypesOptions = {}) => {
   const {
     data,

package/src/hooks/useOrderStatusTypes/useUpdateOrderStatusPriorities/index.ts

@@ -24,6 +24,8 @@ const UPDATE_ORDER_STATUS_PRIORITIES = gql`
 /**
  * Custom hook to update the priority of order statuses.
  *
+ * @param root0
+ * @param root0.sendNotification
  * @returns {{
  *   updatePriorities: (input: OrderStatusPriorityInput[]) => Promise<UpdateStatusPriorityResponse>,
  *   loading: boolean,
@@ -47,16 +49,16 @@ export const useUpdateOrderStatusPriorities = ({
         success: false,
         message: 'Input must be a non-empty array.',
         data: [],
-        errors: [{ path: 'input', message: 'Invalid or empty input array.' }],
+        errors: [{ path: 'input', message: 'Invalid or empty input array.' }]
       }
     }
 
     const isValid = input.every(
       ({ idStatus, priority }) =>
-        typeof idStatus === 'string' &&
+      {return typeof idStatus === 'string' &&
         idStatus.length > 0 &&
         typeof priority === 'number' &&
-        priority >= 0
+        priority >= 0}
     )
 
     if (!isValid) {
@@ -64,7 +66,7 @@ export const useUpdateOrderStatusPriorities = ({
         success: false,
         message: 'Validation failed for one or more input items.',
         data: [],
-        errors: [{ path: 'input', message: 'Each item must have a valid idStatus and priority.' }],
+        errors: [{ path: 'input', message: 'Each item must have a valid idStatus and priority.' }]
       }
     }
 
@@ -88,7 +90,7 @@ export const useUpdateOrderStatusPriorities = ({
         success: false,
         message: 'Unexpected error while updating priorities.',
         data: [],
-        errors: [{ path: 'mutation', message: err.message }],
+        errors: [{ path: 'mutation', message: err.message }]
       }
     }
   }

package/src/hooks/useOrders/{queries.js → queries.ts}

@@ -15,7 +15,7 @@ query getAllOrderStoreFinal($idStore: ID, $search: String, $min: Int, $max: Int,
     pdpId
     idStore
     pCodeRef
-    payMethodPState
+    payId
     pPRecoger
     totalProductsPrice
     pSState
@@ -30,7 +30,7 @@ query getAllOrderStoreFinal($idStore: ID, $search: String, $min: Int, $max: Int,
         ShoppingCard
         pCodeRef
         pPStateP
-        payMethodPState
+        payId
         pPRecoger
         pDatCre
         pDatMod
@@ -64,26 +64,36 @@ query getAllOrderStoreFinal($idStore: ID, $search: String, $min: Int, $max: Int,
 export const GET_ALL_ORDER_FROM_STORE = gql`
 query getAllSalesStore {
   getAllSalesStore {
-      change
-      channel
-      status
+    change
+    channel
+    status
+    createdAt
+    pCodeRef
+    idStore
+    pdpId
+    locationUser
+    shoppingCartRefCode
+    statusOrder {
+      idStatus
+      name
+      description
+      color
+      backgroundColor
+      priority
+      state
       createdAt
-      pCodeRef
-      idStore
-      pdpId
-      locationUser
-      shoppingCartRefCode
-      payMethodPState
       updatedAt
-      totalProductsPrice
-      unidProducts
-      getUser {
-         associateStore
-         avatar
-         createdAt
-         id
-         email
-      }
+    }
+    updatedAt
+    totalProductsPrice
+    unidProducts
+    getUser {
+      associateStore
+      avatar
+      createdAt
+      id
+      email
+    }
   }
 }
 `

package/src/hooks/useOrders/useChangeOrderState/index.ts

@@ -1,4 +1,5 @@
-import { gql, useApolloClient, useMutation } from '@apollo/client'
+import { gql, useApolloClient, useMutation } from '@apollo/client'
+
 import { SendNotificationFn } from '../../useImageUploaderProduct'
 import { updateExistingOrders } from '../../useUpdateExistingOrders'
 /**
@@ -33,93 +34,95 @@ interface IUseChangeStateOrder {
 }
 /**
  * Hook to trigger the `changePPStateOrder` mutation.
+ * @param root0
+ * @param root0.sendNotification
  * @returns {Object} Contains the mutation function, loading and error state.
  */
 export const useChangeStateOrder = ({
-    sendNotification
+  sendNotification
 }: IUseChangeStateOrder) => {
-    const client = useApolloClient()
+  const client = useApolloClient()
 
-    const [changeState, { loading, error, data }] = useMutation(CHANGE_STATE_STORE_ORDER, {
-        onCompleted: (res) => {
-            if (!res || !res.changePPStateOrder) {
-                return
-            }
-            const { success, data } = res?.changePPStateOrder || {}
-            if (success) {
-                const { pCodeRef, pSState } = data ?? {
-                    pCodeRef: null,
-                    pSState: null
-                }
-                if (!pCodeRef || !pSState) {
-                    return
-                }
-                // client.cache.modify({
-                //     fields: {
-                //         getAllOrdersFromStore(existingOrders = []) {
-                //             try {
-                //                 // return 
-                //                 console.log({ cache: updateExistingOrders(existingOrders, pCodeRef, pSState) })
-                //             } catch (e) {
-                //                 return existingOrders
-                //             }
-                //         }
-                //     }
-                // })
-            }
+  const [changeState, { loading, error, data }] = useMutation(CHANGE_STATE_STORE_ORDER, {
+    onCompleted: (res) => {
+      if (!res || !res.changePPStateOrder) {
+        return
+      }
+      const { success, data } = res?.changePPStateOrder || {}
+      if (success) {
+        const { pCodeRef, pSState } = data ?? {
+          pCodeRef: null,
+          pSState: null
         }
-    })
+        if (!pCodeRef || !pSState) {
+          return
+        }
+        // client.cache.modify({
+        //     fields: {
+        //         getAllOrdersFromStore(existingOrders = []) {
+        //             try {
+        //                 // return 
+        //                 console.log({ cache: updateExistingOrders(existingOrders, pCodeRef, pSState) })
+        //             } catch (e) {
+        //                 return existingOrders
+        //             }
+        //         }
+        //     }
+        // })
+      }
+    }
+  })
 
-    /**
-     * Triggers the mutation to update the pedido state.
-     * @param {Object} params
-     * @param {number} params.idStatus - New state of the pedido (required).
-     * @param {string} params.pCodeRef - Reference code for the pedido (required).
-     * @param {string} params.pDatMod - Modification date in ISO format (required).
-     * @returns {Promise<Object>} Response from the mutation.
-     */
-    const changeStateOrder = async ({
-        idStatus,
-        pCodeRef,
-        pDatMod,
-    }: {
+  /**
+   * Triggers the mutation to update the pedido state.
+   * @param {Object} params
+   * @param {number} params.idStatus - New state of the pedido (required).
+   * @param {string} params.pCodeRef - Reference code for the pedido (required).
+   * @param {string} params.pDatMod - Modification date in ISO format (required).
+   * @returns {Promise<Object>} Response from the mutation.
+   */
+  const changeStateOrder = async ({
+    idStatus,
+    pCodeRef,
+    pDatMod
+  }: {
         idStatus: string
         pCodeRef: string
         pDatMod: string
     }) => {
-        try {
-            const response = await changeState({
-                variables:
+    try {
+      const response = await changeState({
+        variables:
                 {
-                    idStatus,
-                    pCodeRef,
-                    pDatMod
-                },
-            })
-            const { success, message } = response?.data?.changePPStateOrder ?? {
-                success: false,
-                message: ''
-            }
-            sendNotification({
-                title: success ? 'Exitoso' : 'Error',
-                description: message,
-                backgroundColor: success ? 'success' : 'error'
-            })
-            return response?.data?.changePPStateOrder ?? {
-                success: false,
-                message,
-            }
-        } catch (err) {
-            return {
-                success: false,
-                message: err.message || 'Unexpected error occurred',
-            }
-        }
+                  idStatus,
+                  pCodeRef,
+                  pDatMod
+                }
+      })
+      const { success, message } = response?.data?.changePPStateOrder ?? {
+        success: false,
+        message: ''
+      }
+      sendNotification({
+        title: success ? 'Exitoso' : 'Error',
+        description: message,
+        backgroundColor: success ? 'success' : 'error'
+      })
+      return response?.data?.changePPStateOrder ?? {
+        success: false,
+        message
+      }
+    } catch (err) {
+      return {
+        success: false,
+        message: err.message || 'Unexpected error occurred'
+      }
     }
+  }
 
-    return [changeStateOrder, {
-        loading,
-        error,
-        data,
-    }]
+  return [changeStateOrder, {
+    loading,
+    error,
+    data
+  }]
 }

package/src/hooks/useOrders/useOrdersFromStore/index.ts

@@ -1,6 +1,7 @@
-import { useQuery } from '@apollo/client'
+import { useQuery } from '@apollo/client'
+import groupBy from 'lodash/groupBy'
+
 import { GET_ALL_ORDER, GET_ALL_ORDER_FROM_STORE } from '../queries.js'
-import groupBy from 'lodash/groupBy'
 
 export const useOrders = ({
   refetchWritePolicy = 'merge',
@@ -53,7 +54,7 @@ export const useOrdersFromStore = ({
     return data
   }
 }) => {
-   const key = 'status'
+  const key = 'status'
   const {
     data,
     loading,

package/src/hooks/usePaymentMethod/index.ts

@@ -0,0 +1,3 @@
+export * from './useCreatePaymentMethod'
+export * from './useGetAllPaymentMethods'
+export * from './useGetPaymentMethod'

package/src/hooks/usePaymentMethod/paymentMethod.gql.ts

@@ -0,0 +1,62 @@
+import { gql } from '@apollo/client'
+
+export const GET_PAYMENT_METHOD = gql`
+  query getPaymentMethod($payId: ID!) {
+    getPaymentMethod(payId: $payId) {
+      payId
+      name
+      icon
+      state
+      paymentPriority
+      createdAt
+      updatedAt
+    }
+  }
+`
+
+export const GET_ALL_PAYMENT_METHODS = gql`
+  query getAllPaymentMethods {
+    getAllPaymentMethods {
+      payId
+      name
+      icon
+      state
+      paymentPriority
+      createdAt
+      updatedAt
+    }
+  }
+`
+
+export const CREATE_PAYMENT_METHOD = gql`
+  mutation createPaymentMethod($input: CreatePaymentMethodInput!) {
+    createPaymentMethod(input: $input) {
+      payId
+      name
+      icon
+      state
+      paymentPriority
+      createdAt
+      updatedAt
+    }
+  }
+`
+
+export const UPDATE_PAYMENT_METHOD = gql`
+  mutation updatePaymentMethod($payId: ID!, $input: UpdatePaymentMethodInput!) {
+    updatePaymentMethod(payId: $payId, input: $input) {
+      payId
+      name
+      icon
+      state
+      paymentPriority
+      updatedAt
+    }
+  }
+`
+
+export const DELETE_PAYMENT_METHOD = gql`
+  mutation deletePaymentMethod($payId: ID!) {
+    deletePaymentMethod(payId: $payId)
+  }
+`

package/src/hooks/usePaymentMethod/paymentMethod.types.ts

@@ -0,0 +1,28 @@
+export interface PaymentMethod {
+  payId: string
+  name: string
+  icon: string
+  state: string
+  paymentPriority: number
+  createdAt?: string
+  updatedAt?: string
+}
+
+export interface CreatePaymentMethodInput {
+  payId: string
+  name: string
+  icon: string
+  state: string
+  paymentPriority: number
+  mIcon?: number
+  mState?: number
+}
+
+export interface UpdatePaymentMethodInput {
+  name?: string
+  icon?: string
+  state?: string
+  paymentPriority?: number
+  mIcon?: number
+  mState?: number
+}

package/src/hooks/usePaymentMethod/useCreatePaymentMethod/index.ts

@@ -0,0 +1,25 @@
+'use client'
+
+import { useMutation } from '@apollo/client'
+
+import { CREATE_PAYMENT_METHOD, GET_ALL_PAYMENT_METHODS } from '../paymentMethod.gql'
+import { CreatePaymentMethodInput, PaymentMethod } from '../paymentMethod.types'
+
+
+export const useCreatePaymentMethod = () => {
+  const [createPaymentMethod, { loading, error }] = useMutation<
+        { createPaymentMethod: PaymentMethod },
+        { input: CreatePaymentMethodInput }
+    >(CREATE_PAYMENT_METHOD, {
+      refetchQueries: [{ query: GET_ALL_PAYMENT_METHODS }]
+    })
+
+  const handleCreate = async (input: CreatePaymentMethodInput) => {
+    const res = await createPaymentMethod({ variables: { input } })
+    return res.data?.createPaymentMethod
+  }
+  return [handleCreate, {
+    loading,
+    error
+  }]
+}

package/src/hooks/usePaymentMethod/useGetAllPaymentMethods/index.ts

@@ -0,0 +1,19 @@
+'use client'
+
+import { useQuery } from '@apollo/client'
+
+import { GET_ALL_PAYMENT_METHODS } from '../paymentMethod.gql'
+import { PaymentMethod } from '../paymentMethod.types'
+
+export const useGetAllPaymentMethods = () => {
+  const { data, loading, error, refetch } = useQuery<{
+    getAllPaymentMethods: PaymentMethod[]
+  }>(GET_ALL_PAYMENT_METHODS)
+
+  return {
+    data: data?.getAllPaymentMethods ?? [],
+    loading,
+    error,
+    refetch
+  }
+}