Method resolveTemplate

apps/sim/executor/variables/resolver.ts:1244–1302

(
    ctx: ExecutionContext,
    currentNodeId: string,
    template: string,
    loopScope?: LoopScope,
    block?: SerializedBlock,
    options: { allowLargeValueRefs?: boolean } = {}
  )

  }

  private async resolveTemplate(
    ctx: ExecutionContext,
    currentNodeId: string,
    template: string,
    loopScope?: LoopScope,
    block?: SerializedBlock,
    options: { allowLargeValueRefs?: boolean } = {}
  ): Promise<string> {
    const resolutionContext: ResolutionContext = {
      executionContext: ctx,
      executionState: this.state,
      currentNodeId,
      loopScope,
      allowLargeValueRefs: options.allowLargeValueRefs,
    }

    let replacementError: Error | null = null

    const blockType = block?.metadata?.id
    const language =
      blockType === BlockType.FUNCTION
        ? ((block?.config?.params as Record<string, unknown> | undefined)?.language as
            | string
            | undefined)
        : undefined

    let result = await replaceValidReferencesAsync(template, async (match) => {
      if (replacementError) return match

      try {
        const resolved = await this.resolveReference(match, resolutionContext)
        if (resolved === undefined) {
          return match
        }

        if (resolved === RESOLVED_EMPTY) {
          if (blockType === BlockType.FUNCTION) {
            return this.blockResolver.formatValueForBlock(null, blockType, language)
          }
          return ''
        }

        return this.blockResolver.formatValueForBlock(resolved, blockType, language)
      } catch (error) {
        replacementError = toError(error)
        return match
      }
    })

    if (replacementError !== null) {
      throw replacementError
    }

    result = await replaceEnvVarsAsync(result, async (match) => {
      const resolved = await this.resolveReference(match, resolutionContext)
      return typeof resolved === 'string' ? resolved : match
    })
    return result