export async function draftWorkflow()

in src/commands/draft/draftCommands.ts [91:171]
66 lines of code
9 McCabe index (conditional complexity)

export async function draftWorkflow(_context: IActionContext, target: unknown): Promise<void> {
    const cloudExplorer = await k8s.extension.cloudExplorer.v1;
    const params = getDraftWorkflowParams(cloudExplorer, target);
    const commonDependencies = await getCommonDraftDependencies(params?.workspaceFolder);
    if (commonDependencies === null) {
        return;
    }

    const { workspaceFolder, extension, draftBinaryPath } = commonDependencies;

    const sessionProvider = await getReadySessionProvider();
    if (failed(sessionProvider)) {
        window.showErrorMessage(sessionProvider.error);
        return;
    }

    // The git API is used to infer the remote repositories associated with the selected workspace.
    // This allows it to provide only the relevant GitHub repositories for the user to pick from.
    const gitApi = getGitApi();
    if (failed(gitApi)) {
        window.showErrorMessage(gitApi.error);
        return;
    }

    const kubectl = await k8s.extension.kubectl.v1;
    if (!kubectl.available) {
        window.showErrorMessage(`Kubectl is unavailable.`);
        return;
    }

    const workspaceRepository = await gitApi.result.openRepository(workspaceFolder.uri);
    if (!workspaceRepository) {
        window.showErrorMessage("The workspace is not a git repository.");
        return;
    }

    const session = await getGitHubAuthenticationSession();
    if (failed(session)) {
        window.showErrorMessage(session.error);
        return;
    }

    // The Octokit instance is used to interact with the GitHub API. This allows the user to
    // select the relevant repository and branch to associate with the workflow file.
    const octokit = new Octokit({
        auth: `token ${session.result.accessToken}`,
    });

    const reposFromRemotes = await Promise.all(workspaceRepository.state.remotes.map((r) => getRepo(octokit, r)));
    const accessibleRepos = reposFromRemotes.filter((f) => f !== null) as GitHubRepo[];

    const workflowsUri = Uri.joinPath(workspaceFolder.uri, ".github", "workflows");
    let existingWorkflowFiles: ExistingFile[] = [];
    try {
        const files = await workspace.fs.readDirectory(workflowsUri);
        existingWorkflowFiles = files
            .filter((f) => f[1] === FileType.File)
            .map((f) => {
                const [name] = f;
                return {
                    name: basename(name, extname(name)),
                    path: join(".github", "workflows", name),
                };
            });
    } catch {
        // If the directory doesn't exist, that's fine - it just means there will be no existing workflow files.
    }

    const panel = new DraftWorkflowPanel(extension.extensionUri);
    const dataProvider = new DraftWorkflowDataProvider(
        sessionProvider.result,
        workspaceFolder,
        draftBinaryPath,
        kubectl,
        session.result,
        accessibleRepos,
        existingWorkflowFiles,
        params?.initialSelection || {},
    );
    panel.show(dataProvider);
}