npm-pkg-hook 1.3.9 → 1.4.0

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

@@ -0,0 +1,55 @@
+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 ref = useRef()
+
+  const setMousePosition = (event) => {
+    if (ref.current) {
+      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 })
+    } else {
+      setPosition({ x: event.clientX, y: event.clientY })
+    }
+  }
+
+  const resetMousePosition = () => {return setPosition({ x: 0, y: 0 })}
+
+  useEffect(() => {
+    const element = ref?.current ? ref.current : document
+    element.addEventListener('mousemove', setMousePosition)
+    if (options.resetOnExit)
+      {element.addEventListener('mouseleave', resetMousePosition)}
+
+    return () => {
+      element.removeEventListener('mousemove', setMousePosition)
+      if (options.resetOnExit)
+        {element.removeEventListener('mouseleave', resetMousePosition)}
+    }
+  }, [ref.current])
+
+  return { ref, ...position }
+}

package/src/hooks/useOrderStatusTypes/index.ts

@@ -0,0 +1,2 @@
+export * from './useUpdateOrderStatusPriorities'
+export * from './useOrderStatusTypes'

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

@@ -0,0 +1,133 @@
+import { useQuery, gql } from '@apollo/client'
+
+/**
+ * GraphQL query to fetch order status types.
+ */
+const GET_ORDER_STATUS_TYPES = gql`
+  query getAllOrderStatusTypes {
+    getAllOrderStatusTypes {
+      message
+      success
+      __typename
+      data {
+        backgroundColor
+        color
+        createdAt
+        description
+        idStatus
+        name
+        priority
+        state
+        updatedAt
+        __typename
+      }
+      pagination {
+        currentPage
+        totalPages
+        totalRecords
+        __typename
+      }
+      errors {
+         context {
+          key
+          label
+          limit
+          value
+          __typename
+         }
+      }
+    }
+  }
+`
+
+/**
+ * @typedef {Object} OrderStatusType
+ * @property {string} idStatus - Unique identifier for the status
+ * @property {string} name - Name of the status
+ * @property {number} priority - Priority level
+ * @property {string} backgroundColor - Background color in hex
+ * @property {string} color - Text color in hex
+ * @property {number} state - Status state (e.g. active/inactive)
+ */
+
+/**
+ * Custom hook to fetch order status types.
+ *
+ * @returns {{
+ *   statusTypes: OrderStatusType[] | null,
+ *   loading: boolean,
+ *   error: Error | undefined,
+ *   refetch: () => void
+ * }}
+ */
+/**
+ * Retrieves order status types via the corresponding GraphQL query and exposes loading state, errors, and refetch capabilities.
+ *
+ * @param options - Optional configuration values for the hook.
+ * @param options.callback - Callback invoked when the query completes successfully, receiving the raw query response.
+ * @returns An object containing the normalized status types data along with loading, error, and refetch helpers.
+ */
+export interface OrderStatusType {
+  idStatus: string
+  name: string
+  priority: number
+  backgroundColor: string
+  color: string
+  state: number
+  description: string
+  createdAt: string
+  updatedAt: string
+  __typename: string
+}
+
+export interface OrderStatusTypeErrorContext {
+  key: string
+  label: string
+  limit: number
+  value: string
+  __typename: string
+}
+
+export interface OrderStatusTypeError {
+  context: OrderStatusTypeErrorContext[]
+  __typename: string
+}
+
+export interface GetAllOrderStatusTypesResponse {
+  message: string
+  success: boolean
+  __typename: string
+  data: OrderStatusType[]
+  errors?: OrderStatusTypeError[] | null
+}
+
+export interface OrderStatusTypesQueryResult {
+  getAllOrderStatusTypes: GetAllOrderStatusTypesResponse
+}
+
+export interface UseOrderStatusTypesOptions {
+  callback?: (payload: OrderStatusTypesQueryResult) => void
+}
+
+export const useOrderStatusTypes = ({
+  callback = () => {return undefined}
+}: UseOrderStatusTypesOptions = {}) => {
+  const {
+    data,
+    loading,
+    error,
+    refetch
+  } = useQuery<OrderStatusTypesQueryResult>(GET_ORDER_STATUS_TYPES, {
+    onCompleted: callback,
+    fetchPolicy: 'cache-and-network'
+  })
+
+  const statusTypes = data?.getAllOrderStatusTypes?.data ?? null
+
+  return {
+    data: statusTypes,
+    loading,
+    error,
+    refetch
+  }
+}

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

@@ -0,0 +1,99 @@
+import { gql, useMutation } from '@apollo/client'
+
+/**
+ * GraphQL mutation to update the priority of order statuses.
+ */
+const UPDATE_ORDER_STATUS_PRIORITIES = gql`
+  mutation UpdateOrderStatusPriorities($data: [OrderStatusPriorityInput!]!) {
+    updateOrderStatusPriorities(data: $data) {
+      success
+      message
+      errors {
+        path
+        message
+      }
+      data {
+        idStatus
+        name
+        priority
+      }
+    }
+  }
+`
+
+/**
+ * Custom hook to update the priority of order statuses.
+ *
+ * @param root0
+ * @param root0.sendNotification
+ * @returns {{
+ *   updatePriorities: (input: OrderStatusPriorityInput[]) => Promise<UpdateStatusPriorityResponse>,
+ *   loading: boolean,
+ *   error: any
+ * }}
+ */
+export const useUpdateOrderStatusPriorities = ({
+  sendNotification = (...res) => { }
+} = {}) => {
+  const [mutate, { loading, error }] = useMutation(UPDATE_ORDER_STATUS_PRIORITIES)
+
+  /**
+   * Executes the mutation to update order status priorities.
+   *
+   * @param {OrderStatusPriorityInput[]} input - Array of objects containing idStatus and priority.
+   * @returns {Promise<UpdateStatusPriorityResponse>} Response from the server.
+   */
+  const updatePriorities = async (input) => {
+    if (!Array.isArray(input) || input.length === 0) {
+      return {
+        success: false,
+        message: 'Input must be a non-empty array.',
+        data: [],
+        errors: [{ path: 'input', message: 'Invalid or empty input array.' }]
+      }
+    }
+
+    const isValid = input.every(
+      ({ idStatus, priority }) =>
+      {return typeof idStatus === 'string' &&
+        idStatus.length > 0 &&
+        typeof priority === 'number' &&
+        priority >= 0}
+    )
+
+    if (!isValid) {
+      return {
+        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.' }]
+      }
+    }
+
+    try {
+      const { data } = await mutate({ variables: { data: input } })
+      if (data) {
+        const { updateOrderStatusPriorities } = data ?? {}
+        const { success, message } = updateOrderStatusPriorities ?? {
+          success: false,
+          message: ''
+        }
+        return sendNotification({
+          title: success ? 'Exitoso' : 'Error',
+          description: message,
+          backgroundColor: success ? 'success' : 'error'
+        })
+      }
+      return data.updateOrderStatusPriorities
+    } catch (err) {
+      return {
+        success: false,
+        message: 'Unexpected error while updating priorities.',
+        data: [],
+        errors: [{ path: 'mutation', message: err.message }]
+      }
+    }
+  }
+
+  return [updatePriorities, { loading, error }]
+}

package/src/hooks/useOrders/index.ts

@@ -0,0 +1,3 @@
+export * from './queries'
+export * from './useChangeOrderState'
+export * from './useOrdersFromStore'

package/src/hooks/useOrders/queries.ts

@@ -0,0 +1,99 @@
+import { gql } from '@apollo/client'
+
+export const CHANGE_STATE_STORE_ORDER = gql`
+mutation changePPStateOrder($pPStateP: Int, $pCodeRef: String, $pDatMod: String) {
+  changePPStateOrder(pPStateP: $pPStateP, pCodeRef: $pCodeRef,  pDatMod: $pDatMod){
+    success
+    message
+  }
+}
+
+`
+export const GET_ALL_ORDER = gql`
+query getAllOrderStoreFinal($idStore: ID, $search: String, $min: Int, $max: Int, $statusOrder: Int, $fromDate:  DateTime, $toDate:  DateTime) {
+  getAllOrderStoreFinal(idStore: $idStore, search: $search, min: $min, max: $max, statusOrder: $statusOrder, toDate: $toDate,fromDate: $fromDate ) {
+    pdpId
+    idStore
+    pCodeRef
+    payId
+    pPRecoger
+    totalProductsPrice
+    pSState
+    pDatCre
+    channel
+    locationUser
+    pDatMod
+    getAllPedidoStore{
+        pdpId
+        pId
+        idStore
+        ShoppingCard
+        pCodeRef
+        pPStateP
+        payId
+        pPRecoger
+        pDatCre
+        pDatMod
+        getAllShoppingCard {
+          ShoppingCard
+          comments
+          cantProducts
+          pId
+        productFood{
+          pId
+          carProId
+          colorId
+          idStore
+          pName
+          ProPrice
+          ProDescuento
+          ProDescription
+          ValueDelivery
+          ProImage
+          ProStar
+          pState
+          pDatCre
+          pDatMod
+        }
+      }
+    }
+  }
+}
+`
+
+export const GET_ALL_ORDER_FROM_STORE = gql`
+query getAllSalesStore {
+  getAllSalesStore {
+    change
+    channel
+    status
+    createdAt
+    pCodeRef
+    idStore
+    pdpId
+    locationUser
+    shoppingCartRefCode
+    statusOrder {
+      idStatus
+      name
+      description
+      color
+      backgroundColor
+      priority
+      state
+      createdAt
+      updatedAt
+    }
+    updatedAt
+    totalProductsPrice
+    unidProducts
+    getUser {
+      associateStore
+      avatar
+      createdAt
+      id
+      email
+    }
+  }
+}
+`

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

@@ -0,0 +1,128 @@
+import { gql, useApolloClient, useMutation } from '@apollo/client'
+
+import { SendNotificationFn } from '../../useImageUploaderProduct'
+import { updateExistingOrders } from '../../useUpdateExistingOrders'
+/**
+ * GraphQL mutation to change the state of a store order (pedido).
+ */
+const CHANGE_STATE_STORE_ORDER = gql`
+  mutation changePPStateOrder($idStatus: ID, $pCodeRef: String, $pDatMod: String) {
+    changePPStateOrder(idStatus: $idStatus, pCodeRef: $pCodeRef, pDatMod: $pDatMod) {
+      success
+      message
+      errors {
+        path
+        message
+        type
+      }
+      data {
+        pdpId
+        id
+        idStore
+        pPStateP
+        pSState
+        
+        ppState
+        pCodeRef
+      }
+    }
+  }
+`
+
+interface IUseChangeStateOrder {
+    sendNotification: SendNotificationFn
+}
+/**
+ * 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
+}: IUseChangeStateOrder) => {
+  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
+        //             }
+        //         }
+        //     }
+        // })
+      }
+    }
+  })
+
+  /**
+   * 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:
+                {
+                  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
+  }]
+}

package/src/hooks/useOrders/{index.js → useOrdersFromStore/index.ts}

@@ -1,5 +1,6 @@
 import { useQuery } from '@apollo/client'
-import { GET_ALL_PEDIDOS, GET_ALL_PEDIDOS_FROM_STORE } from './queries'
+import groupBy from 'lodash/groupBy'
+import { GET_ALL_ORDER, GET_ALL_ORDER_FROM_STORE } from '../queries'
 
 export const useOrders = ({
   refetchWritePolicy = 'merge',
@@ -13,7 +14,7 @@ export const useOrders = ({
   pollInterval = 60000,
   onError
 }) => {
-  const { data, loading, error, fetchMore } = useQuery(GET_ALL_PEDIDOS, {
+  const { data, loading, error, fetchMore } = useQuery(GET_ALL_ORDER, {
     notifyOnNetworkStatusChange: true,
     refetchWritePolicy,
     pollInterval,
@@ -32,7 +33,7 @@ export const useOrders = ({
   })
 
   return [
-    data?.getAllPedidoStoreFinal,
+    data?.getAllOrderStoreFinal,
     { loading, error, data, fetchMore }
   ]
 }
@@ -47,29 +48,30 @@ export const useOrdersFromStore = ({
   fromDate,
   toDate,
   max,
-  statusOrder
+  statusOrder,
+  callback = (data) => {
+    return data
+  }
 }) => {
+  const key = 'status'
   const {
     data,
     loading,
+    refetch,
     error,
     called
-  } = useQuery(GET_ALL_PEDIDOS_FROM_STORE, {
-    variables: {
-      idStore,
-      cId,
-      dId,
-      ctId,
-      search,
-      min,
-      fromDate,
-      toDate,
-      max,
-      statusOrder
+  } = useQuery(GET_ALL_ORDER_FROM_STORE, {
+    notifyOnNetworkStatusChange: true,
+    fetchPolicy: 'network-only',
+    onCompleted: (data) => {
+      if (typeof callback === 'function') {
+        callback(data)
+      }
     }
   })
+  const grouped = groupBy(data?.getAllSalesStore ?? [], key)
+ 
 
-  return [data?.getAllOrdersFromStore || [], { loading: called ? false : loading, error }]
+  return [grouped, { refetch, loading: called ? false : loading, error }]
 }
 
-export * from './queries'