The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.
TypeScript aialternativeauthdatabasedenoembeddingsexamplefirebasenextjsoauth2pgvectorpostgispostgrespostgresqlpostgrestrealtimesupabasevectorswebsockets
import { useSession } from 'common'
import { useCallback, useMemo, useState } from 'react'
import { SECRETS_TOOL_NAME } from './McpSecrets.constants'
import type { DevSecretsState, SecretsParams } from './McpSecrets.params'
import { getProviderHint } from './McpSecrets.providers'
import type { SecretRequest, SecretsState } from './McpSecrets.types'
import { useProjectDetailQuery } from '@/data/projects/project-detail-query'
import {
useSecretsCreateMutation,
type SecretsCreateVariables,
} from '@/data/secrets/secrets-create-mutation'
import { useSecretsQuery } from '@/data/secrets/secrets-query'
type RecordedOutcome = {
ref: string | undefined
name: string | undefined
status: 'stored' | 'cancelled' | 'error'
}
function recordOutcome(
variables: SecretsCreateVariables,
status: RecordedOutcome['status']
): RecordedOutcome {
return { ref: variables.projectRef, name: variables.secrets[0]?.name, status }
}
export function useSecretRequest(params: SecretsParams) {
const { ref, name } = params
const devState = params.dev.state
const session = useSession()
const account = session?.user?.email ?? ''
const [outcome, setOutcome] = useState<RecordedOutcome | undefined>(undefined)
const isLinkResolvable = ref !== undefined && name !== undefined
const project = useProjectDetailQuery({ ref }, { enabled: isLinkResolvable })
const secrets = useSecretsQuery({ projectRef: ref }, { enabled: isLinkResolvable })
const { mutate, isPending: isSaving } = useSecretsCreateMutation({
onSuccess: (_data, variables) => setOutcome(recordOutcome(variables, 'stored')),
onError: (_error, variables) => setOutcome(recordOutcome(variables, 'error')),
})
const request: SecretRequest | undefined = useMemo(() => {
if (ref === undefined || name === undefined || project.data === undefined) return undefined
const existing = secrets.data?.find((secret) => secret.name === name)
return {
tool: SECRETS_TOOL_NAME,
ref,
project: project.data.name,
account,
keyName: name,
providerHint: getProviderHint(name),
existingSecret: existing === undefined ? undefined : { updatedAt: existing.updated_at },
}
}, [account, name, project.data, ref, secrets.data])
const state = useMemo<SecretsState>(() => {
const overridden =
devState === undefined ? undefined : resolveDevState(devState, request, account)
if (overridden !== undefined) return overridden
if (!isLinkResolvable) return { status: 'expired' }
const activeOutcome =
outcome?.ref === ref && outcome?.name === name ? outcome.status : undefined
if (activeOutcome === 'cancelled') return { status: 'cancelled' }
if (activeOutcome === 'error') return { status: 'error' }
if (activeOutcome === 'stored' && request !== undefined) {
return { status: 'stored', request, timedOut: false }
}
if (project.isError || secrets.isError) return { status: 'error' }
if (project.isPending || secrets.isPending || request === undefined) {
return { status: 'loading' }
}
return { status: 'form', request }
}, [
account,
devState,
isLinkResolvable,
name,
outcome,
project.isError,
ref,
project.isPending,
request,
secrets.isError,
secrets.isPending,
])
const saveSecret = useCallback(
(secret: string) => {
if (ref === undefined || name === undefined || isSaving) return
mutate({ projectRef: ref, secrets: [{ name, value: secret }] })
},
[isSaving, mutate, name, ref]
)
const cancelRequest = useCallback(
() => setOutcome({ ref, name, status: 'cancelled' }),
[name, ref]
)
return { state, isSaving, saveSecret, cancelRequest }
}
function resolveDevState(
devState: DevSecretsState,
request: SecretRequest | undefined,
account: string
): SecretsState | undefined {
switch (devState) {
case 'loading':
return { status: 'loading' }
case 'expired':
return { status: 'expired' }
case 'cancelled':
return { status: 'cancelled' }
case 'paused':
return { status: 'paused' }
case 'error':
return { status: 'error' }
case 'wrong-account':
return { status: 'wrong-account', signedInAs: account }
case 'form':
return request && { status: 'form', request }
case 'stored':
return request && { status: 'stored', request, timedOut: false }
case 'stored-timeout':
return request && { status: 'stored', request, timedOut: true }
case 'already-stored':
return request && { status: 'already-stored', request }
}
}