chore: import upstream snapshot with attribution

apps/sim/lib/workflows/comparison/resolve-values.ts

@@ -0,0 +1,285 @@
+import { createLogger } from '@sim/logger'
+import { truncate } from '@sim/utils/string'
+import { buildSelectorContextFromBlock } from '@/lib/workflows/subblocks/context'
+import { getBlock } from '@/blocks/registry'
+import { SELECTOR_TYPES_HYDRATION_REQUIRED, type SubBlockConfig } from '@/blocks/types'
+import { isUuid } from '@/executor/constants'
+import { fetchOAuthCredentialDetail } from '@/hooks/queries/oauth/oauth-credentials'
+import { getSelectorDefinition, loadAllSelectorOptions } from '@/hooks/selectors/registry'
+import { resolveSelectorForSubBlock } from '@/hooks/selectors/resolution'
+import type { SelectorContext, SelectorKey } from '@/hooks/selectors/types'
+import type { WorkflowState } from '@/stores/workflows/workflow/types'
+import { formatParameterLabel } from '@/tools/params'
+
+const logger = createLogger('ResolveValues')
+
+/**
+ * Result of resolving a value for display
+ */
+interface ResolvedValue {
+  /** The original value before resolution */
+  original: unknown
+  /** Human-readable label for display */
+  displayLabel: string
+  /** Whether the value was successfully resolved to a name */
+  resolved: boolean
+}
+
+/**
+ * Context needed to resolve values for display
+ */
+interface ResolutionContext {
+  /** The block type (e.g., 'slack', 'gmail') */
+  blockType: string
+  /** The subBlock field ID (e.g., 'channel', 'credential') */
+  subBlockId: string
+  /** The workflow ID for API calls */
+  workflowId: string
+  /** The workspace scope for selector-based lookups */
+  workspaceId?: string
+  /** The current workflow state for extracting additional context */
+  currentState: WorkflowState
+  /** The block ID being resolved */
+  blockId?: string
+}
+
+function getSemanticFallback(subBlockConfig: SubBlockConfig): string {
+  return (subBlockConfig.title ?? subBlockConfig.id).toLowerCase()
+}
+
+async function resolveCredential(credentialId: string, workflowId: string): Promise<string | null> {
+  try {
+    const credentials = await fetchOAuthCredentialDetail(credentialId, workflowId)
+    if (credentials.length > 0) {
+      return credentials[0].name ?? null
+    }
+
+    return null
+  } catch (error) {
+    logger.warn('Failed to resolve credential', { credentialId, error })
+    return null
+  }
+}
+
+async function resolveWorkflow(workflowId: string, workspaceId?: string): Promise<string | null> {
+  if (!workspaceId) return null
+
+  try {
+    const definition = getSelectorDefinition('sim.workflows')
+    if (definition.fetchById) {
+      const result = await definition.fetchById({
+        key: 'sim.workflows',
+        context: { workspaceId },
+        detailId: workflowId,
+      })
+      return result?.label ?? null
+    }
+    return null
+  } catch (error) {
+    logger.warn('Failed to resolve workflow', { workflowId, error })
+    return null
+  }
+}
+
+async function resolveSelectorValue(
+  value: string,
+  selectorKey: SelectorKey,
+  selectorContext: SelectorContext
+): Promise<string | null> {
+  try {
+    const definition = getSelectorDefinition(selectorKey)
+
+    if (definition.fetchById) {
+      const result = await definition.fetchById({
+        key: selectorKey,
+        context: selectorContext,
+        detailId: value,
+      })
+      if (result?.label) {
+        return result.label
+      }
+    }
+
+    const options = await loadAllSelectorOptions(definition, {
+      key: selectorKey,
+      context: selectorContext,
+    })
+    const match = options.find((opt) => opt.id === value)
+    return match?.label ?? null
+  } catch (error) {
+    logger.warn('Failed to resolve selector value', { value, selectorKey, error })
+    return null
+  }
+}
+
+function extractMcpToolName(toolId: string): string {
+  const withoutPrefix = toolId.startsWith('mcp-') ? toolId.slice(4) : toolId
+  const parts = withoutPrefix.split('_')
+  if (parts.length >= 2) {
+    return parts[parts.length - 1]
+  }
+  return withoutPrefix
+}
+
+/**
+ * Resolves a subBlock field ID to its human-readable title.
+ * Falls back to the raw ID if the block or subBlock is not found.
+ */
+export function resolveFieldLabel(blockType: string, subBlockId: string): string {
+  if (subBlockId.startsWith('data.')) {
+    return formatParameterLabel(subBlockId.slice(5))
+  }
+  const blockConfig = getBlock(blockType)
+  if (!blockConfig) return subBlockId
+  const subBlockConfig = blockConfig.subBlocks.find((sb) => sb.id === subBlockId)
+  return subBlockConfig?.title ?? subBlockId
+}
+
+/**
+ * Resolves a dropdown option ID to its human-readable label.
+ * Returns null if the subBlock is not a dropdown or the value is not found.
+ */
+function resolveDropdownLabel(subBlockConfig: SubBlockConfig, value: string): string | null {
+  if (subBlockConfig.type !== 'dropdown') return null
+  if (!subBlockConfig.options) return null
+  const options =
+    typeof subBlockConfig.options === 'function' ? subBlockConfig.options() : subBlockConfig.options
+  const match = options.find((opt) => opt.id === value)
+  return match?.label ?? null
+}
+
+/**
+ * Formats a value for display in diff descriptions.
+ */
+export function formatValueForDisplay(value: unknown): string {
+  if (value === null || value === undefined) return '(none)'
+  if (typeof value === 'string') {
+    if (value.length > 50) return truncate(value, 50)
+    return value || '(empty)'
+  }
+  if (typeof value === 'boolean') return value ? 'enabled' : 'disabled'
+  if (typeof value === 'number') return String(value)
+  if (Array.isArray(value)) return `[${value.length} items]`
+  if (typeof value === 'object') {
+    const json = JSON.stringify(value)
+    return truncate(json, 50)
+  }
+  return String(value)
+}
+
+function extractSelectorContext(
+  blockId: string,
+  currentState: WorkflowState,
+  workflowId: string,
+  workspaceId?: string
+): SelectorContext {
+  const block = currentState.blocks?.[blockId]
+  if (!block?.subBlocks) return { workflowId, workspaceId }
+  return buildSelectorContextFromBlock(block.type, block.subBlocks, {
+    workflowId,
+    workspaceId,
+    canonicalModes: block.data?.canonicalModes,
+  })
+}
+
+/**
+ * Resolves a value to a human-readable display label.
+ * Uses the selector registry infrastructure to resolve IDs to names.
+ *
+ * @param value - The value to resolve (credential ID, channel ID, UUID, etc.)
+ * @param context - Context needed for resolution (block type, subBlock ID, workflow state)
+ * @returns ResolvedValue with the display label and resolution status
+ */
+export async function resolveValueForDisplay(
+  value: unknown,
+  context: ResolutionContext
+): Promise<ResolvedValue> {
+  if (typeof value !== 'string' || !value) {
+    return {
+      original: value,
+      displayLabel: formatValueForDisplay(value),
+      resolved: false,
+    }
+  }
+
+  const blockConfig = getBlock(context.blockType)
+  const subBlockConfig = blockConfig?.subBlocks.find((sb) => sb.id === context.subBlockId)
+  if (!subBlockConfig) {
+    return { original: value, displayLabel: formatValueForDisplay(value), resolved: false }
+  }
+  const semanticFallback = getSemanticFallback(subBlockConfig)
+
+  const selectorCtx = context.blockId
+    ? extractSelectorContext(
+        context.blockId,
+        context.currentState,
+        context.workflowId,
+        context.workspaceId
+      )
+    : { workflowId: context.workflowId, workspaceId: context.workspaceId }
+
+  const isCredentialField =
+    subBlockConfig.type === 'oauth-input' || context.subBlockId === 'credential'
+
+  if (isCredentialField && isUuid(value)) {
+    const label = await resolveCredential(value, context.workflowId)
+    if (label) {
+      return { original: value, displayLabel: label, resolved: true }
+    }
+    return { original: value, displayLabel: semanticFallback, resolved: true }
+  }
+
+  if (subBlockConfig.type === 'workflow-selector' && isUuid(value)) {
+    const label = await resolveWorkflow(value, selectorCtx.workspaceId)
+    if (label) {
+      return { original: value, displayLabel: label, resolved: true }
+    }
+    return { original: value, displayLabel: semanticFallback, resolved: true }
+  }
+
+  if (subBlockConfig.type === 'mcp-tool-selector') {
+    const toolName = extractMcpToolName(value)
+    return { original: value, displayLabel: toolName, resolved: true }
+  }
+
+  if (subBlockConfig.type === 'dropdown') {
+    try {
+      const label = resolveDropdownLabel(subBlockConfig, value)
+      if (label) {
+        return { original: value, displayLabel: label, resolved: true }
+      }
+    } catch (error) {
+      logger.warn('Failed to resolve dropdown label', {
+        value,
+        subBlockId: context.subBlockId,
+        error,
+      })
+    }
+  }
+
+  if (SELECTOR_TYPES_HYDRATION_REQUIRED.includes(subBlockConfig.type)) {
+    const resolution = resolveSelectorForSubBlock(subBlockConfig, selectorCtx)
+
+    if (resolution?.key) {
+      const label = await resolveSelectorValue(value, resolution.key, selectorCtx)
+      if (label) {
+        return { original: value, displayLabel: label, resolved: true }
+      }
+    }
+    return { original: value, displayLabel: semanticFallback, resolved: true }
+  }
+
+  if (isUuid(value)) {
+    return { original: value, displayLabel: semanticFallback, resolved: true }
+  }
+
+  if (/^C[A-Z0-9]{8,}$/.test(value) || /^[UW][A-Z0-9]{8,}$/.test(value)) {
+    return { original: value, displayLabel: semanticFallback, resolved: true }
+  }
+
+  return {
+    original: value,
+    displayLabel: formatValueForDisplay(value),
+    resolved: false,
+  }
+}