public suspend fun refreshPackagesInfo()

in http/client/src/commonMain/kotlin/org/jetbrains/packagesearch/api/v3/http/PackageSearchApiClient.kt [440:492]
42 lines of code
3 McCabe index (conditional complexity)

    public suspend fun refreshPackagesInfo(
        request: RefreshPackagesInfoRequest,
        requestBuilder: (HttpRequestBuilder.() -> Unit)? = null,
    ): List<ApiPackage> {
        //gather results from cache
        val packagesCache = packagesCacheCollection.await()

        val cachedResults = request.packages
            .associate { it.packageIdHash to it.latestKnownVersion }
            .mapKeys { packagesCache.find(PackageCacheEntry::key.name, it).firstOrNull() }
            .filterKeys { it != null }.mapKeys { it.key!! }
            .map { (cacheEntry, versionName) ->
                when {
                    versionName == null -> cacheEntry // no version specified so any version is fine
                    cacheEntry.value == null -> cacheEntry // We don't know this package at all, so the cached result is ok

                    NormalizedVersion.from(versionName) < cacheEntry.value.versions.latest.normalized ->
                        cacheEntry //we know that the version is outdated, so we need to refresh it

                    NormalizedVersion.from(versionName) > cacheEntry.value.versions.latest.normalized ->
                        PackageCacheEntry(cacheEntry.key, null)//we know that there are no other new versions,
                    // so we can omit this package for online request

                    else -> null
                }
            }.filterNotNull()


        val cachedIdHashes = cachedResults.map { it.key }
        val notFoundPackages = request.packages.filter { it.packageIdHash !in cachedIdHashes }

        if (isOffline || notFoundPackages.isEmpty()) {
            return cachedResults.mapNotNull { it.value }
        }

        val onlineResults =
            defaultRequest<_, List<ApiPackage>>(
                method = HttpMethod.Post,
                url = endpoints.refreshPackagesInfo,
                body = RefreshPackagesInfoRequest(notFoundPackages),
                requestBuilder = requestBuilder,
            )

        onlineResults.forEach {
            packagesCache.updateWhere(
                fieldSelector = PackageCacheEntry::key.name,
                fieldValue = it.idHash,
                upsert = true,
                update = PackageCacheEntry(it.idHash, it)
            )
        }
        return cachedResults.mapNotNull { it.value } + onlineResults
    }