npm-pkg-hook 1.13.0 → 1.13.1

package/src/hooks/usePrintSaleTicket/index.ts

@@ -1,68 +0,0 @@
-// usePrintSaleTicket.ts
-import { gql, useMutation, MutationHookOptions } from '@apollo/client'
-import { useCallback } from 'react'
-
-/* ------------------------------
-   TYPES
------------------------------- */
-
-export interface PrintSaleTicketResponse {
-  printSaleTicket: {
-    message: string
-    success: boolean
-    data: string | null
-    __typename: string
-  }
-}
-
-export interface PrintSaleTicketVars {
-  saleId: string
-}
-
-/* ------------------------------
-   GQL
------------------------------- */
-
-const PRINT_SALE_TICKET = gql`
-  mutation printSaleTicket($saleId: ID!) {
-    printSaleTicket(saleId: $saleId) {
-      message
-      success
-      data
-      __typename
-    }
-  }
-`
-
-/* ------------------------------
-   HOOK
------------------------------- */
-
-/**
- *
- * @param options
- */
-export function usePrintSaleTicket(
-  options?: MutationHookOptions<PrintSaleTicketResponse, PrintSaleTicketVars>
-) {
-  const [runMutation, { loading, data, error }] = useMutation<
-    PrintSaleTicketResponse,
-    PrintSaleTicketVars
-  >(PRINT_SALE_TICKET, options)
-
-  const printSale = useCallback(
-    async (saleId: string) => {
-      const result = await runMutation({
-        variables: { saleId }
-      })
-      return result.data?.printSaleTicket
-    },
-    [runMutation]
-  )
-
-  return [printSale, {
-    loading,
-    data: data?.printSaleTicket,
-    error
-  }]
-}

package/src/hooks/useProductsFood/index.ts

@@ -1,341 +0,0 @@
-import {
-  useApolloClient,
-  useLazyQuery,
-  useMutation,
-  useQuery
-} from '@apollo/client'
-import { useCallback, useMemo, useState } from 'react'
-
-import { useStockUpdatedAllSubscription } from '../useStock'
-
-import {
-  GET_ALL_EXTRA_PRODUCT,
-  GET_ALL_PRODUCT_STORE,
-  GET_EXTRAS_PRODUCT_FOOD_OPTIONAL,
-  GET_ONE_PRODUCTS_FOOD,
-  UPDATE_PRODUCT_FOOD
-} from './queriesStore'
-export * from './useEditProduct'
-
-interface UseProductsFoodOptions {
-  idStore?: string | null
-  categories?: string[]
-  desc?: string[]
-  fetchPolicy?: 'cache-first' | 'cache-and-network' | 'network-only' | 'no-cache'
-  fromDate?: string | null
-  gender?: string[]
-  max?: number
-  min?: number | null
-  pState?: number
-  search?: string | null
-  toDate?: string | null
-  dataSale?: Array<{ pId: string }>
-  isShopppingCard?: boolean
-  callback: (args: any) => void
-}
-export const useProductsFood = ({
-  idStore = null,
-  categories = [],
-  desc = [],
-  fetchPolicy = 'cache-and-network',
-  fromDate = null,
-  gender = [],
-  max = 100,
-  min = null,
-  pState,
-  search = null,
-  toDate = null,
-  dataSale = [],
-  isShopppingCard = false,
-  callback
-}: UseProductsFoodOptions) => {
-  const [showMore, setShowMore] = useState(500)
-  const client = useApolloClient()
-  const variables = useMemo(() => {return {
-    categories,
-    desc,
-    gender,
-    max,
-    min,
-    pState,
-    search
-  }}, [categories, desc, gender, max, min, pState, search, callback])
-
-  const { data, loading, fetchMore, refetch, error, called } = useQuery(GET_ALL_PRODUCT_STORE, {
-    onCompleted: (data) => {
-      callback(data)
-    },
-    fetchPolicy,
-    notifyOnNetworkStatusChange: true,
-    nextFetchPolicy: 'cache-first',
-    refetchWritePolicy: 'merge',
-    variables
-  })
-
-  const productsFood = data?.productFoodsAll?.data ?? []
-  /**
-   * Callback when subscription emits a stock update.
-   * Updates Apollo cache for GET_ALL_PRODUCT_STORE with same variables so UI updates reactively.
-   */
-  const onStockUpdated = useCallback(
-    (payload: any) => {
-      try {
-        if (!payload || !payload.pId) return
-
-        // Try to read current query result from cache (may throw if not present)
-        const cached = client.readQuery({
-          query: GET_ALL_PRODUCT_STORE,
-          variables
-        })
-
-        if (!cached?.productFoodsAll?.data) return
-
-        const updatedData = cached.productFoodsAll.data.map((prod: any) => {
-          if (!prod || prod.pId !== payload.pId) return prod
-
-          // update stock in-place preserving other fields; prefer 'stock' field name but keep others
-          return {
-            ...prod,
-            // if your product model uses another field name replace 'stock' accordingly
-            stock: payload.newStock,
-            previousStock: payload.previousStock ?? prod.previousStock ?? null,
-            // keep a meta object with event info for UI if needed
-            lastStockEvent: {
-              event: payload.event,
-              meta: payload.meta
-            }
-          }
-        })
-
-        // Write back to cache so queries using GET_ALL_PRODUCT_STORE update automatically
-        client.writeQuery({
-          query: GET_ALL_PRODUCT_STORE,
-          variables,
-          data: {
-            ...cached,
-            productFoodsAll: {
-              ...cached.productFoodsAll,
-              data: updatedData
-            }
-          }
-        })
-      } catch (err) {
-        // be silent but log for debugging
-        // (don't throw — subscription should not break the app)
-         
-        console.error('useProductsFood: failed updating cache from subscription', err)
-      }
-    },
-    // include all variables that affect the cache key
-    [client, JSON.stringify(variables)]
-  )
-  // Attach subscription only if idStore is provided (the subscription hook internally skips when idStore is falsy)
-  useStockUpdatedAllSubscription(idStore ?? '', onStockUpdated)
-
-  if (!isShopppingCard) {
-    return [
-      productsFood, {
-        pagination: data?.productFoodsAll?.pagination || {},
-        loading: called ? false : loading,
-        error,
-        showMore,
-        fetchMore,
-        refetch,
-        setShowMore
-      }
-    ]
-  }
-
-  const updatedProductsFood = productsFood.map((product: any) => {return {
-    ...product,
-    existsInSale: Array.isArray(dataSale) && dataSale.some(item => {return item.pId === product.pId})
-  }})
-
-  return [
-    updatedProductsFood,
-    {
-      pagination: data?.productFoodsAll?.pagination || {},
-      loading: called ? false : loading,
-      error,
-      showMore,
-      fetchMore,
-      refetch,
-      setShowMore
-    }
-  ]
-}
-
-export const useDeleteProductsFood = ({
-  sendNotification = (arg) => { return arg },
-  onSuccess = (arg) => { return arg }
-} = {
-  sendNotification: (arg) => { return arg },
-  onSuccess: (arg) => { return arg }
-}) => {
-  const [updateProductFoods, { data, loading, error }] = useMutation(UPDATE_PRODUCT_FOOD)
-
-  const handleDelete = async product => {
-    const { pId, pState } = product || {}
-    return await updateProductFoods({
-      variables: {
-        input: {
-          pId,
-          pState
-        }
-      },
-      update(cache) {
-        cache.modify({
-          fields: {
-            productFoodsAll(dataOld = []) {
-              if (Array.isArray(dataOld) && dataOld?.length) {
-                const product = dataOld?.find((product) => {
-                  return product.pId === pId
-                })
-                if (product) {
-                  const newProductList = dataOld?.filter((product) => {
-                    return product?.pId !== pId
-                  })
-                  return newProductList
-                }
-                return dataOld
-              } 
-              return []
-              
-            }
-          }
-        })
-        cache.modify({
-          fields: {
-            getCatProductsWithProduct(dataOld = []) {
-              if (Array.isArray(dataOld?.catProductsWithProduct) && dataOld?.catProductsWithProduct?.length) {
-                const newListCatProducts = dataOld?.catProductsWithProduct?.map((categories) => {
-                  return {
-                    ...categories,
-                    productFoodsAll: categories?.productFoodsAll?.length
-                      ? categories?.productFoodsAll?.filter((product) => {
-                        return product?.pId !== pId
-                      })
-                      : []
-                  }
-                })
-                return {
-                  catProductsWithProduct: newListCatProducts,
-                  totalCount: newListCatProducts?.length
-                }
-              }
-              return dataOld
-            }
-          }
-        })
-      }
-    }).then(() => {
-      onSuccess()
-      return sendNotification({
-        title: 'Éxito',
-        description: pState === 1 ? 'El producto se ha eliminado correctamente' : 'El producto se ha restaurando correctamente',
-        backgroundColor: 'success'
-      })
-    }).catch((e) => {
-      console.log(e)
-      return sendNotification({
-        title: 'Error',
-        description: 'Ocurrió un error',
-        backgroundColor: 'error'
-      })
-    })
-  }
-  return {
-    handleDelete, data, loading, error
-  }
-}
-
-export const useExtProductFoodsAll = () => {
-  const [ExtProductFoodsAll,
-    {
-      data,
-      loading,
-      error
-    }
-  ] = useLazyQuery(GET_ALL_EXTRA_PRODUCT)
-
-  const handleExtProductFoodsAll = (pId) => {
-    if (!pId) return
-    return ExtProductFoodsAll({
-      variables: {
-        pId
-      }
-    })
-  }
-  return [handleExtProductFoodsAll,
-    {
-      data: data?.ExtProductFoodsAll || [],
-      loading,
-      error
-    }
-  ]
-}
-
-export const useExtProductFoodsOptionalAll = () => {
-  const [ExtProductFoodsOptionalAll,
-    {
-      data,
-      loading,
-      error
-    }] = useLazyQuery(GET_EXTRAS_PRODUCT_FOOD_OPTIONAL)
-
-  const handleGetExtProductFood = (pId) => {
-    try {
-      ExtProductFoodsOptionalAll({
-        variables: {
-          pId
-        }
-      })
-    } catch (e) {
-      console.log(e)
-    }
-  }
-  return [handleGetExtProductFood,
-    {
-      data: data?.ExtProductFoodsOptionalAll || [],
-      loading,
-      error
-    }]
-}
-
-interface UseGetOneProductsFoodOptions {
-  fetchOnlyProduct?: boolean
-}
-export const useGetOneProductsFood = ({ fetchOnlyProduct = false }: UseGetOneProductsFoodOptions = {}) => {
-  const [productFoodsOne,
-    {
-      data,
-      loading,
-      error
-    }] = useLazyQuery(GET_ONE_PRODUCTS_FOOD)
-
-  const [handleGetExtProductFood, { data: dataOptional }] = useExtProductFoodsOptionalAll()
-  const [handleExtProductFoodsAll, { data: dataExtra }] = useExtProductFoodsAll()
-  const handleGetOneProduct = async (food: any) => {
-    const { pId } = food
-    try {
-      const product = await productFoodsOne({
-        variables: {
-          pId
-        }
-      })
-      if (!fetchOnlyProduct) handleGetExtProductFood(pId)
-      if (!fetchOnlyProduct) handleExtProductFoodsAll(pId)
-      return product
-    } catch (e) {
-      console.log(e)
-    }
-  }
-  const handleFunctionQuery = fetchOnlyProduct ? productFoodsOne : handleGetOneProduct
-  return [handleFunctionQuery, {
-    data: data?.productFoodsOne || {},
-    dataExtra,
-    dataOptional,
-    loading,
-    error
-  }]
-}