Function getReposForOrganizations

packages/backend/src/azuredevops.ts:160–229

(
    organizations: string[],
    baseUrl: string,
    token: string,
    useTfsPath: boolean
)

};

async function getReposForOrganizations(
    organizations: string[],
    baseUrl: string,
    token: string,
    useTfsPath: boolean
) {
    const results = await Promise.allSettled(organizations.map(async (org) => {
        try {
            logger.debug(`Fetching repositories for organization ${org}...`);
            
            const { durationMs, data } = await measure(async () => {
                const fetchFn = async () => {
                    const orgUrl = buildOrgUrl(baseUrl, org, useTfsPath);
                    const connection = createAzureDevOpsConnection(orgUrl, token); // useTfsPath already handled in orgUrl
                    
                    const coreApi = await connection.getCoreApi();
                    const gitApi = await connection.getGitApi();
                    
                    const projects = await coreApi.getProjects();
                    const allRepos: GitRepository[] = [];
                    for (const project of projects) {
                        if (!project.id) {
                            logger.warn(`Encountered project in org ${org} with no id: ${project.name}`);
                            continue;
                        }

                        try {
                            const repos = await gitApi.getRepositories(project.id);
                            allRepos.push(...repos);
                        } catch (error) {
                            logger.warn(`Failed to fetch repositories for project ${project.name}: ${error}`);
                        }
                    }

                    return allRepos;
                };

                return fetchWithRetry(fetchFn, `organization ${org}`, logger);
            });

            logger.debug(`Found ${data.length} repositories in organization ${org} in ${durationMs}ms.`);
            return {
                type: 'valid' as const,
                data
            };
        } catch (error) {
            Sentry.captureException(error);
            logger.error(`Failed to fetch repositories for organization ${org}.`, error);

            // Check if it's a 404-like error (organization not found)
            if (error && typeof error === 'object' && 'statusCode' in error && error.statusCode === 404) {
                const warning = `Organization ${org} not found or no access`;
                logger.warn(warning);
                return {
                    type: 'warning' as const,
                    warning
                };
            }