npm-pkg-hook 1.3.8 → 1.4.0

package/src/hooks/useStore/index.ts

@@ -0,0 +1,83 @@
+import { useApolloClient, useQuery } from '@apollo/client'
+import { useState, useEffect } from 'react'
+
+
+import { errorHandler } from '../../config/client'
+import { useLogout } from '../useLogout'
+
+import { GET_ONE_STORE, GET_ONE_STORE_BY_ID } from './queries' // Reemplaza con la importación correcta de tu consulta
+
+export const useStore = ({
+  isClient = false,
+  idStore = null,
+  callback = () => { }
+} = {}) => {
+  const client = useApolloClient()
+  const [onClickLogout, { loading: load }] = useLogout()
+
+  // Variables para almacenar los datos del store
+  const [store, setStore] = useState({})
+  const [loading, setLoading] = useState(false)
+  const [error, setError] = useState(null)
+
+  // Intentar leer los datos de la caché
+  const cachedData = client.readQuery({ query: GET_ONE_STORE })
+
+  useEffect(() => {
+    if (cachedData) {
+      const array = store ? Object.keys(store) : []
+      // Comprobar si los datos de la caché ya están establecidos en el estado
+      if ((!store || Array.isArray(array)) && array?.length === 0) {
+        setStore(cachedData.getStore)
+      }
+    }
+    callback(store)
+  }, [cachedData, store])
+
+  if (isClient && Boolean(idStore)) {
+    const {
+      data,
+      refetch,
+      loading: loadingClient,
+      error: errorStoreClient
+    } = useQuery(GET_ONE_STORE_BY_ID, {
+      skip: !isClient,
+      variables: {
+        idStore
+      }
+    })
+
+    const dataOneStoreClient = !loadingClient ? data?.getOneStore : {}
+
+    return [dataOneStoreClient, {
+      refetch,
+      loading: loadingClient,
+      error: errorStoreClient
+    }]
+  } 
+  const { loading: loadingServer } = useQuery(GET_ONE_STORE, {
+    skip: isClient && !idStore,
+    variables: {
+      idStore
+    },
+    fetchPolicy: 'cache-first',
+    onCompleted: (data) => {
+      const { getStore } = data || {}
+      setStore(getStore)
+      setLoading(false)
+    },
+    onError: (err) => {
+      if (err.networkError && err.networkError.result) {
+        const response = errorHandler(err.networkError.result)
+        if (response) {
+          onClickLogout()
+        }
+      }
+      setError(err)
+      setLoading(false)
+    }
+  })
+
+  return [store, { loading: load || loadingServer || loading, error }]
+  
+}

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

@@ -11,67 +11,68 @@ mutation  newRegisterStore($input: IStore){
 `
 
 export const GET_ONE_STORE = gql`
-query getStore($id: ID, $idStore: ID){
- getStore(id: $id, idStore: $idStore){
-cId
-id
-scheduleOpenAll
-dId
-idStore
-ctId
-neighborhoodStore
-Viaprincipal
-catStore
-storeOwner
-storeName
-ImageName
-emailStore
-storePhone
-socialRaz
-Image
-banner
-  
-documentIdentifier
-uPhoNum
-storeName
-ULocation
-upLat
-upLon
-uState
-siteWeb
-  
-description
-createdAt
-secVia
-NitStore
-typeRegiments
-typeContribute
-addressStore
-pais {
-        cId
-        cName
-        cCalCod
-        cState
-        cDatCre
-        cDatMod
-      }
-      city {
-        ctId
-        dId
-        cName
-        cState
-        cDatCre
-        cDatMod
-      } 
-      department {
-        dId
-        cId
-        dName
-        dState
-        dDatCre
-        dDatMod
-      }
-  getStoreSchedules {
+query getStore($id: ID, $idStore: ID) {
+  getStore(id: $id, idStore: $idStore) {
+    cId
+    id
+    deliveryTimeMinutes
+    scheduleOpenAll
+    dId
+    idStore
+    ctId
+    neighborhoodStore
+    Viaprincipal
+    catStore
+    storeOwner
+    storeName
+    ImageName
+    emailStore
+    storePhone
+    socialRaz
+    Image
+    banner
+
+    documentIdentifier
+    uPhoNum
+    storeName
+    ULocation
+    upLat
+    upLon
+    uState
+    siteWeb
+    dailyGoal
+    description
+    createdAt
+    secVia
+    NitStore
+    typeRegiments
+    typeContribute
+    addressStore
+    pais {
+      cId
+      cName
+      cCalCod
+      cState
+      cDatCre
+      cDatMod
+    }
+    city {
+      ctId
+      dId
+      cName
+      cState
+      cDatCre
+      cDatMod
+    }
+    department {
+      dId
+      cId
+      dName
+      dState
+      dDatCre
+      dDatMod
+    }
+    getStoreSchedules {
       idStore
       schId
       id
@@ -79,17 +80,16 @@ pais {
       schHoSta
       schHoEnd
       schState
+    }
+    cateStore {
+      catStore
+      cName
+      cState
+      createdAt
+      updatedAt
+      csDescription
+    }
   }
-  cateStore {
-    catStore
-    cName
-    cState
-    cDatCre
-    cDatMod
-    csDescription
-    
-  }
-}
 }
 `
 export const GET_ONE_STORE_BY_ID = gql`

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

@@ -1,5 +1,6 @@
 import { useQuery, useMutation, useLazyQuery } from '@apollo/client'
-import { useState } from 'react'
+import { useState } from 'react'
+
 import {
   GET_ALL_CONTACTS,
   EDIT_ONE_CONTACT,
@@ -7,22 +8,27 @@ import {
   GET_ONE_CONTACT
 } from './queries'
 
+interface UseStoreContactsParams {
+  sendNotification?: (message: string, type?: 'error' | 'success') => void
+  max?: number
+  search?: string
+}
 export const useGetStoreContacts = ({
   sendNotification = () => { },
   max,
   search = ''
-} = {}) => {
-  const [clientes, setUseStoreContacts] = useState([])
+}: UseStoreContactsParams = {}) => {
+  const [clientes, setClientes] = useState<{ getAllContacts?: any[] } | undefined>(undefined)
   const { loading, error, fetchMore, called } = useQuery(GET_ALL_CONTACTS, {
     variables: {
       max,
       search
     },
     onCompleted: (data) => {
-      setUseStoreContacts(data)
+      setClientes(data)
     }
   })
-  return [clientes?.getAllContacts || [], { loading: called ? false : loading, error, fetchMore }]
+  return [clientes?.getAllContacts ?? [], { loading: called ? false : loading, error, fetchMore }]
 }
 
 export const useDeleteUseStoreContacts = ({ sendNotification = () => { } } = {}) => {

package/src/hooks/useStoreTable/index.ts

@@ -0,0 +1,2 @@
+export * from './useStoreTableCreate'
+export * from './useStoreTables'

package/src/hooks/useStoreTable/queries.ts

@@ -0,0 +1,47 @@
+import { gql } from '@apollo/client'
+
+/**
+ * GraphQL Mutation for creating a store table
+ */
+export const CREATE_TABLE_MUTATION = gql`
+  mutation storeTableCreate($tableName: String!, $seats: Int, $section: String, $tableState: Int) {
+    storeTableCreate(tableName: $tableName, seats: $seats, section: $section, tableState: $tableState) {
+      success
+      message
+      errors {
+        message
+        path
+        type
+        context {
+          limit
+          value
+          label
+          key
+        }
+      }
+      data {
+        tableId
+        tableName
+        seats
+        section
+        tableState
+        createdAt
+        updatedAt
+      }
+    }
+  }
+`
+
+export const STORE_TABLES_QUERY = gql`
+  query {
+    storeTables {
+      tableId
+      tableName
+      seats
+      section
+      tableState
+      createdAt
+      updatedAt
+    }
+  }
+`

package/src/hooks/useStoreTable/useStoreTableCreate.ts

@@ -0,0 +1,77 @@
+import { useMutation } from '@apollo/client'
+import { useState } from 'react'
+
+import { CREATE_TABLE_MUTATION } from './queries'
+
+/**
+ * Custom hook to handle table creation with validation and mutation logic
+ * @param {string} tableName Name of the table
+ * @param {number} seats Number of seats at the table
+ * @param {string} section Section where the table is located
+ * @param {number} tableState Current state of the table (e.g., Active, Occupied)
+ * @returns {Object} The state of the mutation including success, message, errors, and data
+ */
+export const useStoreTableCreate = ({
+  sendNotification = () => {}
+} = {}) => {
+  const [loading, setLoading] = useState(false)
+  const [createTableMutation] = useMutation(CREATE_TABLE_MUTATION)
+  /**
+   * Function to create a table with validation and mutation
+   * @param {string} tableName Table name
+   * @param {number} seats Number of seats
+   * @param {string} section Table section
+   * @param {number} tableState Table state (e.g., 0 = Unavailable, 1 = Active, 2 = Occupied)
+   */
+  const storeTableCreate = async (tableName, seats, section, tableState) => {
+    setLoading(true) // Start loading
+    try {
+      // Call the mutation to create the table
+      const result = await createTableMutation({
+        variables: {
+          tableName,
+          seats,
+          section,
+          tableState
+        },
+        update (cache, { data: { storeTableCreate } }) {
+          if (storeTableCreate.success) {
+            // Actualizar la lista de mesas en la caché
+            cache.modify({
+              fields: {
+                storeTables (existingTables = []) {
+                  const newTableRef = {
+                    tableId: null,
+                    tableName,
+                    seats,
+                    section,
+                    tableState: 1
+                  }
+                  return [...existingTables, newTableRef]
+                }
+              }
+            })
+          }
+        }
+      })
+
+      sendNotification({
+        backgroundColor: result.data.storeTableCreate.success ? 'success' : 'error',
+        description: result.data.storeTableCreate.message || '',
+        title: result.data.storeTableCreate.success ? 'Success' : 'Error'
+      })
+      return result
+    } catch (error) {
+      sendNotification({
+        backgroundColor: 'error',
+        description: error.message || 'Error occurred while creating the table.',
+        title: 'Creation Failed'
+      })
+      return { success: false, message: error.message }
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  return [storeTableCreate, { loading }]
+}

package/src/hooks/useStoreTable/useStoreTables.ts

@@ -0,0 +1,15 @@
+import { useQuery } from '@apollo/client'
+
+import { STORE_TABLES_QUERY } from './queries' // Ajusta la ruta a tu archivo de queries
+
+/**
+ * Custom hook to fetch store tables data
+ * @param {Object} args - Arguments for fetching store tables, e.g., info field.
+ * @param {Object} ctx - Context that provides restaurant-related information.
+ * @returns {Object} - Object containing tables data, loading state, and error.
+ */
+export const useStoreTables = () => {
+  const { data, loading, error } = useQuery(STORE_TABLES_QUERY)
+
+  return [data, { loading, error }]
+}

package/src/hooks/useSubscriptionValidation/index.ts

@@ -0,0 +1,112 @@
+import { gql, useQuery } from '@apollo/client'
+import { useEffect, useState } from 'react'
+
+/**
+ * GraphQL query to validate free subscription
+ */
+const VALIDATE_SUBSCRIPTION_QUERY = gql`
+  query validateFreeSubscription($idStore: ID) {
+    validateFreeSubscription(idStore: $idStore) {
+      subscriptionId
+      status
+      businessName
+      currentPeriodEnd
+      currentPeriodStart
+    }
+  }
+`
+
+/**
+ * Subscription entity returned by the API
+ */
+export interface SubscriptionData {
+  subscriptionId: string
+  status: string
+  businessName: string
+  currentPeriodEnd: string
+  currentPeriodStart: string
+}
+
+/**
+ * GraphQL query response shape
+ */
+interface ValidateSubscriptionResponse {
+  validateFreeSubscription: SubscriptionData
+}
+
+/**
+ * Hook return type
+ */
+export interface UseSubscriptionValidationResult {
+  loading: boolean
+  error?: Error
+  subscriptionData?: SubscriptionData
+  daysRemaining: number | null
+  daysElapsed: number | null
+}
+
+/**
+ * Hook to validate store subscription and calculate elapsed/remaining days.
+ * Keeps original behavior and calculations intact.
+ *
+ * @param {string} idStore - Store identifier
+ * @returns {UseSubscriptionValidationResult}
+ */
+export const useSubscriptionValidation = (
+  idStore: string
+): UseSubscriptionValidationResult => {
+  const { loading, error, data } = useQuery<ValidateSubscriptionResponse>(
+    VALIDATE_SUBSCRIPTION_QUERY,
+    {
+      variables: { idStore }
+    }
+  )
+
+  const [daysRemaining, setDaysRemaining] = useState<number | null>(null)
+  const [daysElapsed, setDaysElapsed] = useState<number | null>(null)
+
+  useEffect(() => {
+    if (data?.validateFreeSubscription) {
+      const { currentPeriodEnd, currentPeriodStart } =
+        data.validateFreeSubscription
+
+      const currentDate = new Date()
+      const endOfPeriod = new Date(parseInt(currentPeriodEnd, 10))
+      const startOfPeriod = new Date(parseInt(currentPeriodStart, 10))
+
+      const differenceInTimeUntilEnd =
+        endOfPeriod.getTime() - currentDate.getTime()
+
+      const differenceInDaysUntilEnd = Math.ceil(
+        differenceInTimeUntilEnd / (1000 * 3600 * 24)
+      )
+
+      setDaysRemaining(
+        isNaN(differenceInDaysUntilEnd)
+          ? 0
+          : differenceInDaysUntilEnd
+      )
+
+      const differenceInTimeSinceStart =
+        currentDate.getTime() - startOfPeriod.getTime()
+
+      const differenceInDaysSinceStart = Math.ceil(
+        differenceInTimeSinceStart / (1000 * 3600 * 24)
+      )
+
+      setDaysElapsed(
+        isNaN(differenceInDaysSinceStart)
+          ? 0
+          : differenceInDaysSinceStart
+      )
+    }
+  }, [data])
+
+  return {
+    loading,
+    error: error ?? undefined,
+    subscriptionData: data?.validateFreeSubscription,
+    daysRemaining,
+    daysElapsed
+  }
+}

package/src/hooks/useTagProducts/index.ts

@@ -0,0 +1,3 @@
+export * from './useRegisterMultipleTags'
+export * from './useGetAllTags'
+export * from './useDeleteOneTag'

package/src/hooks/useTagProducts/useDeleteOneTag.ts

@@ -0,0 +1,106 @@
+import { gql, useMutation } from '@apollo/client'
+
+/**
+ * GraphQL mutation to delete a tag by ID or name.
+ */
+const DELETE_ONE_TAG = gql`
+  mutation deleteOneTag($tgId: ID, $nameTag: String) {
+    deleteOneTag(tgId: $tgId, nameTag: $nameTag) {
+      success
+      message
+      data {
+        tgId
+        nameTag
+        state
+      }
+      errors {
+        path
+        message
+        type
+      }
+    }
+  }
+`
+
+/**
+ * Custom hook to delete a tag by ID or name.
+ * @returns {Object} An object with the deleteTag function and mutation state.
+ */
+export const useDeleteOneTag = () => {
+  const [deleteOneTag, { data, loading, error }] = useMutation(DELETE_ONE_TAG, {
+    update(cache, { data }) {
+      const deleted = data?.deleteOneTag?.data
+      const success = data?.deleteOneTag?.success
+
+      if (!success || !deleted?.tgId) return
+
+      // Update cache for getAllTags
+      cache.modify({
+        fields: {
+          getAllTags(existing = {}) {
+            const filteredData = existing?.data?.filter(
+              (tag: any) => {return tag.tgId !== deleted.tgId}
+            ) || []
+
+            return {
+              ...existing,
+              data: filteredData,
+              pagination: {
+                ...existing.pagination,
+                totalRecords: Math.max((existing.pagination?.totalRecords || 1) - 1, 0)
+              }
+            }
+          }
+        }
+      })
+    },
+    // optional, remove if you prefer default behavior
+    onError(err) {
+      console.error('❌ Apollo error in deleteOneTag:', err)
+    }
+  })
+  /**
+   * Deletes a tag by ID or name.
+   * @param {Object} variables - Mutation input.
+   * @param {string} [variables.tgId] - Tag ID (optional).
+   * @param {string} [variables.nameTag] - Tag name (optional).
+   * @returns {Promise<Object>} Response from server.
+   */
+  const handleDeleteTag = async ({
+    tgId,
+    nameTag
+  }: {
+        tgId?: string
+        nameTag?: string
+    }) => {
+    try {
+      const { data } = await deleteOneTag({
+        variables: {
+          tgId,
+          nameTag
+        }
+      })
+
+      return data.deleteOneTag
+    } catch (err: any) {
+      return {
+        success: false,
+        message: 'An error occurred while deleting the tag.',
+        data: null,
+        errors: [
+          {
+            path: 'mutation',
+            message: err.message || 'Unknown error',
+            type: 'server'
+          }
+        ]
+      }
+    }
+  }
+
+  return [handleDeleteTag, {
+    data,
+    loading,
+    error
+  }]
+}