The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.
TypeScript aialternativeauthdatabasedenoembeddingsexamplefirebasenextjsoauth2pgvectorpostgispostgrespostgresqlpostgrestrealtimesupabasevectorswebsockets
import { useQuery } from '@tanstack/react-query'
import { useFlag } from 'common'
import type { CloudProvider } from 'shared-data'
import { AWS_REGIONS } from 'shared-data'
import { miscKeys } from './keys'
import { COUNTRY_LAT_LON } from '@/components/interfaces/ProjectCreation/ProjectCreation.constants'
import { getAvailableRegions } from '@/components/interfaces/ProjectCreation/ProjectCreation.utils'
import { AWS_REGIONS_COORDINATES } from '@/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.constants'
import { fetchHandler } from '@/data/fetchers'
import { getDistanceLatLonKM, tryParseJson } from '@/lib/helpers'
import type { ResponseError, UseCustomQueryOptions } from '@/types'
export type DefaultRegionVariables = {
cloudProvider?: CloudProvider
restrictedPool?: string[]
useRestrictedPool?: boolean
}
// The geolocation-based default may only ever pick a region the selected cloud provider
// actually offers (e.g. AWS_NIMBUS is restricted to a single region). The flag-based
// restricted pool narrows within that set, and is ignored if it would leave no candidates.
export function getDefaultRegionCandidateKeys(
cloudProvider: CloudProvider,
restrictedPool?: string[],
environment = process.env.NEXT_PUBLIC_ENVIRONMENT
) {
const providerRegionKeys = Object.keys(getAvailableRegions(cloudProvider, environment))
const pooledRegionKeys = restrictedPool
? providerRegionKeys.filter((key) => restrictedPool.includes(key))
: providerRegionKeys
return pooledRegionKeys.length > 0 ? pooledRegionKeys : providerRegionKeys
}
export async function getDefaultRegionOption({
cloudProvider,
restrictedPool,
useRestrictedPool = true,
}: DefaultRegionVariables) {
if (!cloudProvider) throw new Error('Cloud provider is required')
try {
const data = await fetchHandler('https://www.cloudflare.com/cdn-cgi/trace').then((res) =>
res.text()
)
const locationCode: keyof typeof COUNTRY_LAT_LON = Object.fromEntries(
data.split('\n').map((item) => item.split('='))
)['loc']
const locLatLon = COUNTRY_LAT_LON[locationCode]
if (locLatLon === undefined) return undefined
const candidateKeys = getDefaultRegionCandidateKeys(
cloudProvider,
useRestrictedPool ? restrictedPool : undefined
)
const locations = Object.fromEntries(
Object.entries(AWS_REGIONS_COORDINATES).filter(([key]) => candidateKeys.includes(key))
)
const distances = Object.keys(locations).map((reg) => {
const region: { lat: number; lon: number } = {
lat: locations[reg][1],
lon: locations[reg][0],
}
return getDistanceLatLonKM(locLatLon.lat, locLatLon.lon, region.lat, region.lon)
})
const shortestDistance = Math.min(...distances)
const closestRegion = Object.keys(locations)[distances.indexOf(shortestDistance)]
return AWS_REGIONS[closestRegion as keyof typeof AWS_REGIONS].displayName
} catch (error) {
throw error
}
}
export type DefaultRegionData = Awaited<ReturnType<typeof getDefaultRegionOption>>
export type DefaultRegionError = ResponseError
export const useDefaultRegionQuery = <TData = DefaultRegionData>(
{ cloudProvider, useRestrictedPool }: DefaultRegionVariables,
{
enabled = true,
...options
}: UseCustomQueryOptions<DefaultRegionData, DefaultRegionError, TData> = {}
) => {
// [Joshen] Flag allows us to specify restricted regions for users based on percentage
const restrictedPoolFlag = useFlag('defaultRegionRestrictedPool')
const restrictedPool = tryParseJson(restrictedPoolFlag)
return useQuery<DefaultRegionData, DefaultRegionError, TData>({
queryKey: miscKeys.defaultRegion(cloudProvider, useRestrictedPool ?? true),
queryFn: () => getDefaultRegionOption({ cloudProvider, restrictedPool, useRestrictedPool }),
enabled:
enabled && typeof cloudProvider !== 'undefined' && typeof restrictedPool !== 'undefined',
retry(failureCount) {
return failureCount < 1
},
...options,
})
}