Function getMetadataBatch

src/Data/UserData.js:201–258

(displayNames, isRefresh = false, {priority = FOREGROUND_PRIORITY} = {})

}

export async function getMetadataBatch(displayNames, isRefresh = false, {priority = FOREGROUND_PRIORITY} = {}) {
    const uniqueDisplayNames = [...new Set(displayNames)].filter(Boolean);
    const requestEpoch = getCacheEpoch();
    const entries = await Promise.all(uniqueDisplayNames.map((displayName) => (
        readCacheEntry(metadataCacheKey(displayName), {legacyFields: ["result"], requestEpoch})
    )));
    if (requestEpoch !== getCacheEpoch()) {
        return {};
    }

    const cachedMetadata = Object.fromEntries(uniqueDisplayNames.flatMap((displayName, index) => (
        entries[index] ? [[displayName, metadataWithLatestYear(entries[index].value)]] : []
    )));
    const expiredDisplayNames = uniqueDisplayNames.filter((displayName, index) => (
        isCacheEntryExpired(entries[index], isRefresh)
    ));
    const request = beginCacheRequests(expiredDisplayNames.map(metadataCacheKey), priority, requestEpoch);
    const requestDisplayNames = request.keys.map(displayNameFromMetadataCacheKey);

    if (requestDisplayNames.length === 0) {
        return cachedMetadata;
    }

    try {
        const response = await apiJson(GET_METADATA_BATCH, {
            body: {display_names: requestDisplayNames},
            fetchPriority: priority,
        });
        const refreshedRawMetadata = requestDisplayNames.reduce((metadataByName, displayName) => ({
            ...metadataByName,
            [displayName]: response.data?.[displayName] ?? null,
        }), {});
        const cacheWrites = requestDisplayNames.map((displayName) => {
            const key = metadataCacheKey(displayName);
            return writeCacheValue(key, refreshedRawMetadata[displayName], {
                requestEpoch: request.epoch,
                requestVersion: request.versionFor(key),
            });
        });
        if (priority === BACKGROUND_PRIORITY) {
            await Promise.all(cacheWrites);
        } else {
            cacheWrites.forEach((cacheWrite) => void cacheWrite.catch(() => {
            }));
        }
        const refreshedMetadata = Object.fromEntries(
            Object.entries(refreshedRawMetadata).map(([displayName, metadata]) => (
                [displayName, metadataWithLatestYear(metadata)]
            ))
        );
        return {
            ...cachedMetadata,
            ...refreshedMetadata,
        };
    } finally {
        request.release();
    }
}