Skip to content

The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.

3.7 KB
Raw Blame
import { useParams } from 'common'

import {
  calculateIOPSPrice,
  calculateThroughputPrice,
} from '@/components/interfaces/DiskManagement/DiskManagement.utils'
import {
  DISK_PRICING,
  DiskType,
} from '@/components/interfaces/DiskManagement/ui/DiskManagement.constants'
import { useDiskAttributesQuery } from '@/data/config/disk-attributes-query'
import { useProjectAddonsQuery } from '@/data/subscriptions/project-addons-query'
import { formatCurrency } from '@/lib/helpers'

export const useGetReplicaCost = () => {
  const { ref: projectRef } = useParams()
  const {
    data: addons,
    isError: isAddonsError,
    isFetching: isAddonsFetching,
    isPending: isAddonsPending,
    refetch: refetchAddons,
  } = useProjectAddonsQuery({ projectRef })
  const {
    data: diskConfiguration,
    isError: isDiskConfigurationError,
    isFetching: isDiskConfigurationFetching,
    isPending: isDiskConfigurationPending,
    refetch: refetchDiskConfiguration,
  } = useDiskAttributesQuery({ projectRef })

  const isLoading =
    (addons === undefined && (isAddonsPending || isAddonsFetching)) ||
    (diskConfiguration === undefined && (isDiskConfigurationPending || isDiskConfigurationFetching))
  const isError =
    (addons === undefined && isAddonsError) ||
    (diskConfiguration === undefined && isDiskConfigurationError)

  const retry = async () => {
    await Promise.all([refetchAddons(), refetchDiskConfiguration()])
  }

  const currentComputeAddon = addons?.selected_addons.find(
    (addon) => addon.type === 'compute_instance'
  )?.variant.identifier
  const computeAddons =
    addons?.available_addons.find((addon) => addon.type === 'compute_instance')?.variants ?? []
  const selectedComputeMeta = computeAddons.find(
    (addon) => addon.identifier === currentComputeAddon
  )
  const estComputeMonthlyCost = Math.floor((selectedComputeMeta?.price ?? 0) * 730) // 730 hours in a month

  // @ts-ignore API types issue
  const { size_gb, type, throughput_mbps, iops } = diskConfiguration?.attributes ?? {}
  const readReplicaDiskSizes = (size_gb ?? 0) * 1.25
  const additionalCostDiskSize =
    readReplicaDiskSizes * (DISK_PRICING[type as DiskType]?.storage ?? 0)
  const additionalCostIOPS = calculateIOPSPrice({
    oldStorageType: type as DiskType,
    newStorageType: type as DiskType,
    oldProvisionedIOPS: 0,
    newProvisionedIOPS: iops ?? 0,
    numReplicas: 0,
  }).newPrice
  const additionalCostThroughput =
    type === 'gp3'
      ? calculateThroughputPrice({
          storageType: type as DiskType,
          newThroughput: throughput_mbps ?? 0,
          oldThroughput: 0,
          numReplicas: 0,
        }).newPrice
      : 0

  const totalCost = formatCurrency(
    estComputeMonthlyCost +
      additionalCostDiskSize +
      Number(additionalCostIOPS) +
      Number(additionalCostThroughput)
  )

  return {
    isLoading,
    isError,
    retry,
    totalCost,
    compute: {
      label: selectedComputeMeta?.name,
      cost: formatCurrency(estComputeMonthlyCost),
      priceDescription: selectedComputeMeta?.price_description,
    },
    disk: {
      type,
      label:
        size_gb !== undefined && size_gb !== null && type !== undefined && type !== null
          ? `${(size_gb * 1.25).toLocaleString()} GB (${type})`
          : undefined,
      cost: formatCurrency(additionalCostDiskSize),
    },
    iops: {
      label: iops !== undefined && iops !== null ? `${iops.toLocaleString()} IOPS` : undefined,
      cost: formatCurrency(+additionalCostIOPS),
    },
    throughput: {
      label:
        throughput_mbps !== undefined && throughput_mbps !== null
          ? `${throughput_mbps.toLocaleString()} MB/s`
          : undefined,
      cost: formatCurrency(+additionalCostThroughput),
    },
  }
}