npm-pkg-hook 1.11.6 → 1.12.0

package/package.json

@@ -39,11 +39,12 @@
     "type": "git",
     "url": "https://github.com/Jesus123780/pkg-hook"
   },
+  "private": false,
   "scripts": {
     "lint": "eslint .",
     "lint:fix": "npm run lint -- --fix",
     "rm": "rm -rf node_modules package-lock.json && npm i",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "version": "1.11.6"
-}
+  "version": "1.12.0"
+}

package/src/config/client/errors.js

@@ -5,7 +5,7 @@ export const errorHandler = (error) => {
   if (error && Array.isArray(error?.errors)) {
     error.errors?.length && error?.errors?.forEach(err => {
       if (err?.extensions) {
-        const { code, message: { message } } = err?.extensions || {}
+        const { code, message } = err?.extensions || {}
         if (code === 'UNAUTHENTICATED' || code === 'FORBIDDEN') {
           logout = true
           return {

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

@@ -142,3 +142,4 @@ export * from './usePortFetcher'
 export * from './useImageUploaderProduct'
 export * from './useTagProducts'
 export * from './useOrderStatusTypes'
+export * from './useCreateOrderStatusType'

package/src/hooks/newStoreOrderSubscription/index.js

@@ -11,7 +11,6 @@ const NEW_STORE_ORDER_SUBSCRIPTION = gql`
 `
 
 export const newStoreOrderSubscription = (idStore, onOrderReceived) => {
-  console.log('🚀 ~ newStoreOrderSubscription ~ idStore:', idStore)
   const subscription = useSubscription(NEW_STORE_ORDER_SUBSCRIPTION, {
     variables: { idStore },
     onSubscriptionData: ({ client, subscriptionData }) => {

package/src/hooks/useCreateOrderStatusType/index.ts

@@ -0,0 +1,105 @@
+import { gql, useMutation } from '@apollo/client'
+
+const CREATE_ORDER_STATUS_TYPE = gql`
+  mutation CreateOrderStatusType($data: OrderStatusTypeInput!) {
+    createOrderStatusType(data: $data) {
+      success
+      message
+      data {
+        idStatus
+        name
+        description
+        color
+        priority
+        createdAt
+        updatedAt
+      }
+      errors {
+        message
+        path
+        type
+        __typename
+      }
+    }
+  }
+`
+
+interface OrderStatusTypeInput {
+  name: string
+  description?: string
+  color?: string
+  priority?: number
+  state?: number
+}
+
+interface OrderStatusType {
+  idStatus: string
+  name: string
+  description: string
+  color: string
+  priority: number
+  createdAt: string
+  updatedAt: string
+}
+
+interface ResponseOrderStatusType {
+  success: boolean
+  message: string
+  data?: OrderStatusType
+  errors?: Array<{
+    message: string
+    path?: string
+    type?: string
+    __typename?: string
+  }>
+}
+
+/**
+ * 🧩 Hook personalizado para crear un OrderStatusType
+ */
+export const useCreateOrderStatusType = ({
+  sendNotification
+}: {
+  sendNotification: (options: {
+    title: string
+    description: string
+    backgroundColor: 'success' | 'error' | 'info' | 'warning'
+  }) => void
+}) => {
+  const [createOrderStatusType, { data, loading, error }] =useMutation<{ createOrderStatusType: ResponseOrderStatusType }>(CREATE_ORDER_STATUS_TYPE, {
+    onCompleted: (data) => {
+      const createOrderStatusType = data.createOrderStatusType
+      const { success, message } = createOrderStatusType ?? {
+        success: false,
+        message: 'Error desconocido'
+      }
+      sendNotification({
+        title: success ? 'Estado de orden creado' : 'Error al crear el estado de orden',
+        description: message,
+        backgroundColor: success ? 'success' : 'error',
+      })
+    }
+  })
+
+  const handleCreateStatus = async (input: OrderStatusTypeInput) => {
+    try {
+      const response = await createOrderStatusType({
+        variables: { data: input },
+      })
+      return response.data?.createOrderStatusType
+    } catch (err) {
+      sendNotification({
+        title: 'Error al crear el estado de orden',
+        description: 'Ha ocurrido un error inesperado al crear el estado de orden.',
+        backgroundColor: 'error',
+      })
+      throw err
+    }
+  }
+
+  return [handleCreateStatus, {
+    data: data?.createOrderStatusType,
+    loading,
+    error,
+  }]
+}

package/src/hooks/useManageNewOrder/index.js

@@ -65,28 +65,28 @@ export const useManageNewOrder = ({
         }
       }).then((response) => {
         console.log(response)
-        const currentSale = response?.data?.getOneSalesStore || {}
+        // const currentSale = response?.data?.getOneSalesStore || {}
         client.cache.modify({
           fields: {
-            getAllOrdersFromStore (existingOrders = []) {
-              try {
-                const cache = updateExistingOrders(
-                  existingOrders,
-                  pCodeRef,
-                  1,
-                  currentSale
-                )
-                const currentOrder = cache[KEY_STATUS_ORDER]
-                const filteredOrders = currentOrder.filter(order =>
-                  isDateInRange(order.pDatCre)
-                )
-                setOrders(filteredOrders)
-                playNotificationSound()
-                return cache
-              } catch (e) {
-                return existingOrders
-              }
-            }
+            // getAllOrdersFromStore (existingOrders = []) {
+            //   try {
+            //     const cache = updateExistingOrders(
+            //       existingOrders,
+            //       pCodeRef,
+            //       1,
+            //       currentSale
+            //     )
+            //     const currentOrder = cache[KEY_STATUS_ORDER]
+            //     const filteredOrders = currentOrder.filter(order =>
+            //       isDateInRange(order.pDatCre)
+            //     )
+            //     setOrders(filteredOrders)
+            //     playNotificationSound()
+            //     return cache
+            //   } catch (e) {
+            //     return existingOrders
+            //   }
+            // }
           }
         })
       })

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

@@ -6,12 +6,36 @@ import { useQuery, gql } from '@apollo/client'
 const GET_ORDER_STATUS_TYPES = gql`
   query getAllOrderStatusTypes {
     getAllOrderStatusTypes {
-      idStatus
-      name
-      priority
-      backgroundColor
-      color
-      state
+      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
+         }
+      }
     }
   }
 `
@@ -36,15 +60,72 @@ const GET_ORDER_STATUS_TYPES = gql`
  *   refetch: () => void
  * }}
  */
-export const useOrderStatusTypes = () => {
-  const { data, loading, error, refetch } = useQuery(GET_ORDER_STATUS_TYPES, {
+/**
+ * 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 = () => undefined
+}: UseOrderStatusTypesOptions = {}) => {
+  const {
+    data,
+    loading,
+    error,
+    refetch
+  } = useQuery<OrderStatusTypesQueryResult>(GET_ORDER_STATUS_TYPES, {
+    onCompleted: callback,
     fetchPolicy: 'cache-and-network'
   })
 
-  const statusTypes = data?.getAllOrderStatusTypes ?? null
+  const statusTypes = data?.getAllOrderStatusTypes?.data ?? null
 
   return {
-    statusTypes,
+    data: statusTypes,
     loading,
     error,
     refetch

package/src/hooks/useOrders/queries.js

@@ -61,104 +61,29 @@ query getAllOrderStoreFinal($idStore: ID, $search: String, $min: Int, $max: Int,
 }
 `
 
-export const GET_ALL_PEDIDOS_FROM_STORE = gql`
-query getAllOrdersFromStore(
-  $idStore: ID
-  $cId: ID
-  $dId: ID
-  $ctId: ID
-  $search: String
-  $min: Int
-  $fromDate: DateTime
-  $toDate: DateTime
-  $max: Int
-  $statusOrder: Int
-) {
-  getAllOrdersFromStore(
-    idStore: $idStore
-    cId: $cId
-    dId: $dId
-    ctId: $ctId
-    search: $search
-    min: $min
-    fromDate: $fromDate
-    toDate: $toDate
-    max: $max
-    statusOrder: $statusOrder
-  ) {
-    statusKey
-    priority
-    state
-    getStatusOrderType {
-      idStatus
-      backgroundColor
-      name
-      description
-      color
-      priority
-      state
+export const GET_ALL_ORDER_FROM_STORE = gql`
+query getAllSalesStore {
+  getAllSalesStore {
+      change
+      channel
+      status
       createdAt
-      updatedAt
-    }
-    items {
-      pdpId
-      idStore
       pCodeRef
+      idStore
+      pdpId
+      locationUser
+      shoppingCartRefCode
       payMethodPState
-      pPRecoger
+      updatedAt
       totalProductsPrice
-      pSState
-      pDatCre
-      channel
-      locationUser
-      pDatMod
-      getStatusOrderType {
-        idStatus
-        name
-        description
-        backgroundColor
-        color
-        priority
-        state
-        createdAt
-        updatedAt
-      }
-      getStoreOrders {
-        pdpId
-        pId
-        idStore
-        ShoppingCard
-        pCodeRef
-        pPStateP
-        payMethodPState
-        pPRecoger
-        pDatCre
-        pDatMod
-        getAllShoppingCard {
-          ShoppingCard
-          comments
-          cantProducts
-          pId
-          productFood {
-            pId
-            carProId
-            colorId
-            idStore
-            pName
-            ProPrice
-            ProDescuento
-            ProDescription
-            ValueDelivery
-            ProImage
-            ProStar
-            pState
-            pDatCre
-            pDatMod
-          }
-        }
+      unidProducts
+      getUser {
+         associateStore
+         avatar
+         createdAt
+         id
+         email
       }
-    }
   }
 }
-
 `

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

@@ -54,18 +54,18 @@ export const useChangeStateOrder = ({
                 if (!pCodeRef || !pSState) {
                     return
                 }
-                client.cache.modify({
-                    fields: {
-                        getAllOrdersFromStore(existingOrders = []) {
-                            try {
-                                // return 
-                                console.log({ cache: updateExistingOrders(existingOrders, pCodeRef, pSState) })
-                            } catch (e) {
-                                return existingOrders
-                            }
-                        }
-                    }
-                })
+                // client.cache.modify({
+                //     fields: {
+                //         getAllOrdersFromStore(existingOrders = []) {
+                //             try {
+                //                 // return 
+                //                 console.log({ cache: updateExistingOrders(existingOrders, pCodeRef, pSState) })
+                //             } catch (e) {
+                //                 return existingOrders
+                //             }
+                //         }
+                //     }
+                // })
             }
         }
     })

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

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

package/src/hooks/useSales/index.js

@@ -1118,18 +1118,18 @@ export const useSales = ({
                 const currentSale = responseSale?.data?.getOneSalesStore || {}
                 const inComingCodeRef = currentSale?.pCodeRef || null
                 if (!inComingCodeRef) return
-                client.cache.modify({
-                  fields: {
-                    getAllOrdersFromStore (existingOrders = []) {
-                      try {
-                        const newGetAllOrdersFromStore = updateExistingOrders(existingOrders, inComingCodeRef, 4, currentSale)
-                        return newGetAllOrdersFromStore
-                      } catch (e) {
-                        return existingOrders
-                      }
-                    }
-                  }
-                })
+                // client.cache.modify({
+                //   fields: {
+                //     getAllOrdersFromStore (existingOrders = []) {
+                //       try {
+                //         const newGetAllOrdersFromStore = updateExistingOrders(existingOrders, inComingCodeRef, 4, currentSale)
+                //         return newGetAllOrdersFromStore
+                //       } catch (e) {
+                //         return existingOrders
+                //       }
+                //     }
+                //   }
+                // })
               }
             })
             router.push(