The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.
TypeScript aialternativeauthdatabasedenoembeddingsexamplefirebasenextjsoauth2pgvectorpostgispostgrespostgresqlpostgrestrealtimesupabasevectorswebsockets
import { z } from 'zod'
import { captureCriticalError } from '@/lib/error-reporting'
import { normalizeRegion, type StatusItem } from '@/lib/status-page/status-page.utils'
export const RESTRICTED_REGIONS_FLAG_KEY = 'projectCreationRestrictedRegions'
export type PlatformRegionStatus = 'capacity' | 'other'
const FLAG_RESTRICTIONS = ['unavailable'] as const
export type FlagRestriction = (typeof FLAG_RESTRICTIONS)[number]
export type RegionRestriction = PlatformRegionStatus | FlagRestriction
export type RegionRestrictionCopy = {
badge: string
title: string
tooltip: string
notice: string
}
const GENERIC_RESTRICTION_COPY: RegionRestrictionCopy = {
badge: 'Unavailable',
title: 'Selected region is unavailable',
tooltip: 'Temporarily unavailable for new projects.',
notice: 'This region is temporarily unavailable for new projects.',
}
export const REGION_RESTRICTION_COPY: Record<RegionRestriction, RegionRestrictionCopy> = {
capacity: {
badge: 'Unavailable',
title: 'Selected region is at capacity',
tooltip: 'Temporarily unavailable due to this region being at capacity.',
notice:
'This region currently has capacity for Micro compute and above. Free plan projects run on Nano compute.',
},
other: GENERIC_RESTRICTION_COPY,
unavailable: GENERIC_RESTRICTION_COPY,
}
export const SELECT_DIFFERENT_REGION = 'Select a different region to continue.'
function isKnownRestriction(value: string): value is RegionRestriction {
return Object.prototype.hasOwnProperty.call(REGION_RESTRICTION_COPY, value)
}
export function getRegionRestrictionCopy(restriction: string): RegionRestrictionCopy {
return isKnownRestriction(restriction)
? REGION_RESTRICTION_COPY[restriction]
: GENERIC_RESTRICTION_COPY
}
export function getRegionRestrictionMessage(restriction: string) {
return `${getRegionRestrictionCopy(restriction).title}. ${SELECT_DIFFERENT_REGION}`
}
const RestrictedRegionsSchema = z.record(z.string(), z.enum(FLAG_RESTRICTIONS))
export function parseRestrictedRegions(flagValue: unknown): Record<string, FlagRestriction> {
if (typeof flagValue !== 'string' || flagValue.trim() === '') return {}
let payload: unknown
try {
payload = JSON.parse(flagValue)
} catch {
reportInvalidPayload(flagValue, 'invalid JSON')
return {}
}
const result = RestrictedRegionsSchema.safeParse(payload)
if (!result.success) {
reportInvalidPayload(flagValue, result.error.issues[0]?.message ?? 'invalid shape')
return {}
}
return result.data
}
function reportInvalidPayload(flagValue: string, reason: string) {
captureCriticalError(
new Error(`Ignoring ${RESTRICTED_REGIONS_FLAG_KEY} flag (${reason}): ${flagValue}`),
'parse restricted regions flag'
)
}
type ResolveRegionRestrictionArgs = {
platformStatus: string | undefined
flagRestriction: FlagRestriction | undefined
}
export function resolveRegionRestriction({
platformStatus,
flagRestriction,
}: ResolveRegionRestrictionArgs): string | undefined {
return platformStatus ?? flagRestriction
}
// Maps smart region group codes to the specific-region code prefixes they contain.
// Used to check whether a status item affecting specific regions also affects a smart region selection.
export const SMART_REGION_PREFIXES: Record<string, Array<string>> = {
americas: ['us-', 'ca-', 'sa-'],
emea: ['eu-', 'me-', 'af-'],
apac: ['ap-'],
}
export function regionMatches(selectedCode: string, affectedRegion: string): boolean {
const normalizedSelected = normalizeRegion(selectedCode)
const normalizedAffected = normalizeRegion(affectedRegion)
if (normalizedSelected === normalizedAffected) return true
return (SMART_REGION_PREFIXES[normalizedSelected] ?? []).some((prefix) =>
normalizedAffected.startsWith(prefix)
)
}
export function getItemsAffectingProjectCreation(
items: Array<StatusItem>,
selectedRegionCode: string | undefined
): Array<StatusItem> {
return items.filter((item) => {
if (item.kind !== 'incident' && item.kind !== 'maintenance') return false
if (item.projectCreationScope === null) return false
if (item.projectCreationScope.type === 'global') return true
return (
selectedRegionCode !== undefined &&
item.projectCreationScope.regions.some((region) => regionMatches(selectedRegionCode, region))
)
})
}