public async getItem()

in api/GitApi.ts [1911:1974]
56 lines of code
3 McCabe index (conditional complexity)

    public async getItem(
        repositoryId: string,
        path: string,
        project?: string,
        scopePath?: string,
        recursionLevel?: GitInterfaces.VersionControlRecursionType,
        includeContentMetadata?: boolean,
        latestProcessedChange?: boolean,
        download?: boolean,
        versionDescriptor?: GitInterfaces.GitVersionDescriptor,
        includeContent?: boolean,
        resolveLfs?: boolean,
        sanitize?: boolean
        ): Promise<GitInterfaces.GitItem> {
        if (path == null) {
            throw new TypeError('path can not be null or undefined');
        }

        return new Promise<GitInterfaces.GitItem>(async (resolve, reject) => {
            let routeValues: any = {
                project: project,
                repositoryId: repositoryId
            };

            let queryValues: any = {
                path: path,
                scopePath: scopePath,
                recursionLevel: recursionLevel,
                includeContentMetadata: includeContentMetadata,
                latestProcessedChange: latestProcessedChange,
                download: download,
                versionDescriptor: versionDescriptor,
                includeContent: includeContent,
                resolveLfs: resolveLfs,
                sanitize: sanitize,
            };
            
            try {
                let verData: vsom.ClientVersioningData = await this.vsoClient.getVersioningData(
                    "6.1-preview.1",
                    "git",
                    "fb93c0db-47ed-4a31-8c20-47552878fb44",
                    routeValues,
                    queryValues);

                let url: string = verData.requestUrl!;
                let options: restm.IRequestOptions = this.createRequestOptions('application/json', 
                                                                                verData.apiVersion);

                let res: restm.IRestResponse<GitInterfaces.GitItem>;
                res = await this.rest.get<GitInterfaces.GitItem>(url, options);

                let ret = this.formatResponse(res.result,
                                              GitInterfaces.TypeInfo.GitItem,
                                              false);

                resolve(ret);
                
            }
            catch (err) {
                reject(err);
            }
        });
    }