Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

5.2 KB
Raw Blame
import type { HumanInputV2Recipient } from './types'

const EMAIL_PATTERN = /^[^\s@.]+(?:\.[^\s@.]+)*@[^\s@.]+(?:\.[^\s@.]+)+$/

export type RecipientValidationError = 'contact-required' | 'selector-required' | 'email-invalid'

export function getRecipientValidationError(
  recipient: HumanInputV2Recipient,
): RecipientValidationError | undefined {
  if (recipient.type === 'contact' && !recipient.contact_id.trim()) return 'contact-required'
  if (
    recipient.type === 'dynamic_email' &&
    (!recipient.selector.length || recipient.selector.some((part) => !part.trim()))
  )
    return 'selector-required'
  if (recipient.type === 'onetime_email' && !EMAIL_PATTERN.test(recipient.email.trim()))
    return 'email-invalid'
}

export function getRecipientCanonicalKey(recipient: HumanInputV2Recipient): string | undefined {
  if (getRecipientValidationError(recipient)) return undefined

  switch (recipient.type) {
    case 'contact':
      return `contact:${recipient.contact_id}`
    case 'dynamic_email':
      return `dynamic_email:${recipient.selector.join('.')}`
    case 'onetime_email':
      return `onetime_email:${recipient.email.trim().toLowerCase()}`
    case 'initiator':
    case 'all_workspace_contacts':
      return recipient.type
  }
}

export function hasDuplicateRecipients(recipients: HumanInputV2Recipient[]): boolean {
  const keys = recipients.map(getRecipientCanonicalKey).filter((key): key is string => !!key)
  return new Set(keys).size !== keys.length
}

export function addRecipient(
  recipients: HumanInputV2Recipient[],
  recipient: HumanInputV2Recipient,
): HumanInputV2Recipient[] {
  const key = getRecipientCanonicalKey(recipient)
  if (!key || recipients.some((item) => getRecipientCanonicalKey(item) === key)) return recipients
  return [...recipients, recipient]
}

export function findConflictingContact<T extends { id: string; email: string }>(
  recipients: HumanInputV2Recipient[],
  candidate: { id: string; email: string },
  contacts: readonly T[],
): T | undefined {
  const email = candidate.email.trim().toLowerCase()
  if (!email) return undefined

  return contacts.find(
    (contact) =>
      contact.id !== candidate.id &&
      contact.email.trim().toLowerCase() === email &&
      recipients.some(
        (recipient) => recipient.type === 'contact' && recipient.contact_id === contact.id,
      ),
  )
}

export function replaceContactRecipient(
  recipients: HumanInputV2Recipient[],
  previousContactId: string,
  nextContactId: string,
): HumanInputV2Recipient[] {
  if (
    !nextContactId.trim() ||
    recipients.some(
      (recipient) => recipient.type === 'contact' && recipient.contact_id === nextContactId,
    )
  )
    return recipients

  const index = recipients.findIndex(
    (recipient) => recipient.type === 'contact' && recipient.contact_id === previousContactId,
  )
  return updateRecipient(recipients, index, { type: 'contact', contact_id: nextContactId })
}

export function updateRecipient(
  recipients: HumanInputV2Recipient[],
  index: number,
  recipient: HumanInputV2Recipient,
): HumanInputV2Recipient[] {
  if (!recipients[index]) return recipients
  return recipients.map((item, itemIndex) => (itemIndex === index ? recipient : item))
}

export type RecipientSummary = {
  state: 'empty' | 'configured' | 'overflow' | 'invalid'
  contactCount: number
  dynamicEmailCount: number
  onetimeEmailCount: number
  hasInitiator: boolean
  hasAllWorkspaceContacts: boolean
  visibleLabels: string[]
  overflowCount: number
}

export function deriveRecipientSummary(
  recipients: HumanInputV2Recipient[],
  contactLabels?: ReadonlyMap<string, string>,
  visibleLimit = 3,
): RecipientSummary {
  if (!recipients.length) {
    return {
      state: 'empty',
      contactCount: 0,
      dynamicEmailCount: 0,
      onetimeEmailCount: 0,
      hasInitiator: false,
      hasAllWorkspaceContacts: false,
      visibleLabels: [],
      overflowCount: 0,
    }
  }

  let invalid = hasDuplicateRecipients(recipients)
  let contactCount = 0
  let dynamicEmailCount = 0
  let onetimeEmailCount = 0
  let hasInitiator = false
  let hasAllWorkspaceContacts = false
  const labels = recipients.map((recipient) => {
    if (getRecipientValidationError(recipient)) invalid = true
    if (recipient.type === 'contact') {
      contactCount += 1
      const label = contactLabels?.get(recipient.contact_id)
      if (contactLabels && !contactLabels.has(recipient.contact_id)) invalid = true
      return label || recipient.contact_id || 'contact'
    }
    if (recipient.type === 'dynamic_email') {
      dynamicEmailCount += 1
      return recipient.selector.join(' / ') || 'dynamic_email'
    }
    if (recipient.type === 'onetime_email') {
      onetimeEmailCount += 1
      return recipient.email
    }
    if (recipient.type === 'all_workspace_contacts') {
      hasAllWorkspaceContacts = true
      return 'all_workspace_contacts'
    }
    hasInitiator = true
    return 'initiator'
  })
  const overflowCount = Math.max(0, labels.length - visibleLimit)

  return {
    state: invalid ? 'invalid' : overflowCount ? 'overflow' : 'configured',
    contactCount,
    dynamicEmailCount,
    onetimeEmailCount,
    hasInitiator,
    hasAllWorkspaceContacts,
    visibleLabels: labels.slice(0, visibleLimit),
    overflowCount,
  }
}