Function getReposForOrgs

packages/backend/src/github.ts:366–427

(orgs: string[], octokit: Octokit, signal: AbortSignal, url?: string)

}

const getReposForOrgs = async (orgs: string[], octokit: Octokit, signal: AbortSignal, url?: string) => {
    const results = await Promise.allSettled(orgs.map((org) => githubQueryLimit(async () => {
        try {
            logger.debug(`Fetching repository info for org ${org}...`);

            const octokitToUse = await getOctokitWithGithubApp(octokit, org, url, `org ${org}`);
            const { durationMs, data } = await measure(async () => {
                // @note: We use paginate.iterator() instead of paginate() to check
                // signal.aborted between pages. paginate() only passes the signal to
                // individual fetch requests but doesn't check abort state between pages.
                const fetchFn = async () => {
                    const allRepos: OctokitRepository[] = [];
                    const iterator = octokitToUse.paginate.iterator(octokitToUse.repos.listForOrg, {
                        org: org,
                        per_page: 100,
                        request: {
                            signal
                        }
                    });

                    for await (const { data: repos } of iterator) {
                        if (signal.aborted) {
                            throw new DOMException('Operation aborted', 'AbortError');
                        }
                        allRepos.push(...repos);
                    }

                    return allRepos;
                };

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

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

            if (isHttpError(error, 404)) {
                const warning = `Organization ${org} not found or no access`;
                logger.warn(warning);
                return {
                    type: 'warning' as const,
                    warning
                };
            }
            throw error;
        }
    })));

    throwIfAnyFailed(results);
    const { validItems: repos, warnings } = processPromiseResults<OctokitRepository>(results);

    return {