async function updateTaskManifests()

in BuildTasks/Common/Common.ts [425:471]
38 lines of code
14 McCabe index (conditional complexity)

async function updateTaskManifests(manifestPaths: string[], updateTasksId: boolean, updateTasksVersion: boolean) : Promise<[string, string][]> {
    const tasksIds: [string, string][] = [];

    await Promise.all(manifestPaths.map(async (extensionPath) => {
        const manifest: any = await getManifest(extensionPath);
        const taskManifestPaths: string[] = getTaskManifestPaths(extensionPath, manifest);

        if (taskManifestPaths && taskManifestPaths.length) {
            await Promise.all(taskManifestPaths.map(async (taskPath) => {
                tl.debug(`Patching: ${taskPath}.`);
                let taskManifest: any = await getManifest(taskPath);

                if (updateTasksId) {
                    tl.debug(`Updating Id...`);
                    const publisherId = tl.getInput("publisherId", false) || manifest.publisher;
                    const extensionTag = tl.getInput("extensionTag", false) || "";
                    const extensionId = `${(tl.getInput("extensionId", false) || manifest.id)}${extensionTag}`;

                    const originalTaskId: string = taskManifest.id || null;
                    taskManifest = updateTaskId(taskManifest, publisherId, extensionId);
                    const newTaskId: string = taskManifest.id;

                    if(originalTaskId && (originalTaskId !== newTaskId)) {
                        tasksIds.push([originalTaskId, newTaskId])
                    }
                }

                if (updateTasksVersion) {
                    tl.debug(`Updating version...`);
                    const extensionVersion = tl.getInput("extensionVersion", false) || manifest.version;
                    if (!extensionVersion) {
                        throw new Error(
                            "Extension Version was not supplied nor does the extension manifest define one.");
                    }
                    const extensionVersionType = tl.getInput("updateTasksVersionType", false) || "major";

                    taskManifest = updateTaskVersion(taskManifest, extensionVersion, extensionVersionType);
                }

                await writeManifest(taskManifest, taskPath);
                tl.debug(`Updated: ${taskPath}.`);
            }));
        }
    }));

    return tasksIds;
}