dify/web/features/deployments/shared/components/runtime-credential-bindings-utils.ts

import type {
  CredentialCandidate,
  CredentialSelectionInput,
  CredentialSlot,
} from '@dify/contracts/enterprise/types.gen'

export type RuntimeCredentialBindingSelections = Record<string, string>

export type RuntimeCredentialSelectOption = {
  value: string
  label: string
}

const PROVIDER_DISPLAY_NAMES: Record<string, string> = {
  azure_openai: 'Azure OpenAI',
  bedrock: 'Amazon Bedrock',
  gemini: 'Gemini',
  google: 'Google',
  openai: 'OpenAI',
  vertex_ai: 'Vertex AI',
  volcengine_maas: 'Volcengine',
}

function providerSlug(providerId: string) {
  const parts = providerId.split('/').filter(Boolean)
  return parts[parts.length - 1]
}

function titleCaseProviderName(value: string) {
  return value
    .split(/[-_]/)
    .filter(Boolean)
    .map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`)
    .join(' ')
}

export function runtimeCredentialSlotKey(slot: CredentialSlot) {
  return [slot.providerId, slot.category].join(':')
}

export function runtimeCredentialProviderName(providerId: string) {
  const slug = providerSlug(providerId)
  if (!slug) return undefined

  return PROVIDER_DISPLAY_NAMES[slug.toLowerCase()] ?? titleCaseProviderName(slug)
}

function runtimeCredentialCandidateLabel(candidate: CredentialCandidate) {
  const fallback = candidate.credentialId
  const rawLabel = candidate.displayName.trim() || fallback
  const providerId = candidate.providerId.trim()

  const providerSuffixes = [` · ${providerId}`, ` - ${providerId}`, ` (${providerId})`]
  const label = providerSuffixes.reduce((nextLabel, suffix) => {
    return nextLabel.endsWith(suffix) ? nextLabel.slice(0, -suffix.length).trim() : nextLabel
  }, rawLabel)

  return label || fallback
}

export function runtimeCredentialCandidateOptions(
  slot: CredentialSlot,
): RuntimeCredentialSelectOption[] {
  return slot.candidates.map((candidate) => ({
    value: candidate.credentialId,
    label: runtimeCredentialCandidateLabel(candidate),
  }))
}

export function hasMissingRequiredRuntimeCredentialBinding(
  _slot: CredentialSlot,
  selectedValue?: string,
) {
  return !selectedValue
}

export function selectedRuntimeCredentialSelections(
  slots: CredentialSlot[],
  manualBindings: RuntimeCredentialBindingSelections,
): RuntimeCredentialBindingSelections {
  const next: RuntimeCredentialBindingSelections = {}
  for (const slot of slots) {
    const slotKey = runtimeCredentialSlotKey(slot)
    const candidates = runtimeCredentialCandidateOptions(slot)
    const existing = manualBindings[slotKey]
    if (existing && candidates.some((candidate) => candidate.value === existing))
      next[slotKey] = existing
    else if (
      slot.lastCredentialId &&
      candidates.some((candidate) => candidate.value === slot.lastCredentialId)
    )
      next[slotKey] = slot.lastCredentialId
    else if (candidates.length === 1 && candidates[0]) next[slotKey] = candidates[0].value
  }
  return next
}

export function selectedDeploymentRuntimeCredentials(
  slots: CredentialSlot[],
  selections: RuntimeCredentialBindingSelections,
): CredentialSelectionInput[] {
  return slots.flatMap((slot): CredentialSelectionInput[] => {
    const slotKey = runtimeCredentialSlotKey(slot)
    const selectedValue = selections[slotKey]
    if (!selectedValue) return []

    return [
      {
        providerId: slot.providerId,
        category: slot.category,
        credentialId: selectedValue,
      },
    ]
  })
}