Class BlockResolver

apps/sim/executor/variables/resolvers/block.ts:26–406

import type { SerializedBlock, SerializedWorkflow } from '@/serializer/types'

export class BlockResolver implements Resolver {
  private nameToBlockId: Map<string, string>
  private blockById: Map<string, SerializedBlock>
  private blockIdsInSubflows: Set<string>
  private subflowContainerIds: Set<string>

  constructor(
    private workflow: SerializedWorkflow,
    private navigatePathAsync?: AsyncPathNavigator
  ) {
    this.nameToBlockId = new Map()
    this.blockById = new Map()
    this.blockIdsInSubflows = new Set()
    this.subflowContainerIds = new Set([
      ...Object.keys(workflow.loops ?? {}),
      ...Object.keys(workflow.parallels ?? {}),
    ])
    for (const block of workflow.blocks) {
      this.blockById.set(block.id, block)
      if (block.metadata?.name) {
        // Name uniqueness is enforced at the normalized level on create/rename,
        // but legacy workflows may contain names that collide only now that
        // normalizeName strips dots. Dot-free names keep ownership of the key so
        // previously working references never change targets.
        const normalizedName = normalizeName(block.metadata.name)
        const incumbentId = this.nameToBlockId.get(normalizedName)
        const incumbentName = incumbentId
          ? this.blockById.get(incumbentId)?.metadata?.name
          : undefined
        if (!incumbentId || incumbentName?.includes('.')) {
          this.nameToBlockId.set(normalizedName, block.id)
        }
      }
    }
    for (const loop of Object.values(workflow.loops ?? {})) {
      for (const blockId of loop.nodes ?? []) {
        this.blockIdsInSubflows.add(blockId)
      }
    }
    for (const parallel of Object.values(workflow.parallels ?? {})) {
      for (const blockId of parallel.nodes ?? []) {
        this.blockIdsInSubflows.add(blockId)
      }
    }
  }

  canResolve(reference: string): boolean {
    if (!isReference(reference)) {
      return false
    }
    const parts = parseReferencePath(reference)
    if (parts.length === 0) {
      return false
    }
    const [type] = parts
    return !(SPECIAL_REFERENCE_PREFIXES as readonly string[]).includes(type)
  }