Function MapCollectionWithLookups

pkg/util/util.go:131–205

MapCollectionWithLookups does a 'map' operation over the collection, transforming each input row into an output row according to `mapper`, however it also provides the ability to collect ID's of related items as it iterates the collection, and call out to lambdas to look those values up. See the uni

(
	cacheContainer *MapCollectionCacheContainer, // cache for keys (typically this will store a mapping of ID->[Name, Name]).
	collection []T, // input (e.g. list of Releases)
	keySelector func(T) []string, // fetches the keys (e.g given a Release, returns the [ChannelID, ProjectID]
	mapper func(T, []string) TResult, // fetches the value to lookup (e.g given a Release and the [ChannelName,ProjectName], does the mapping to return the output struct)
	runLookups ...func([]string) ([]string, error), // callbacks to go fetch values for the keys (given a list of Channel IDs, it should return the list of associated Channel Names)
)

// items as it iterates the collection, and call out to lambdas to look those values up.
// See the unit tests for examples which should clarify the use-cases for this.
func MapCollectionWithLookups[T any, TResult any](
	cacheContainer *MapCollectionCacheContainer, // cache for keys (typically this will store a mapping of ID->[Name, Name]).
	collection []T, // input (e.g. list of Releases)
	keySelector func(T) []string, // fetches the keys (e.g given a Release, returns the [ChannelID, ProjectID]
	mapper func(T, []string) TResult, // fetches the value to lookup (e.g given a Release and the [ChannelName,ProjectName], does the mapping to return the output struct)
	runLookups ...func([]string) ([]string, error), // callbacks to go fetch values for the keys (given a list of Channel IDs, it should return the list of associated Channel Names)
) ([]TResult, error) {
	// if the caller didn't specify an external cache, create an internal one.
	// it'll work, but we lose the ability to cache across multiple lookups
	// (e.g. when fetching more than one page of results from the server)
	if cacheContainer == nil {
		cacheContainer = &MapCollectionCacheContainer{}
	}

	if len(cacheContainer.Caches) < len(runLookups) {
		// caches aren't allocated, we need to do that
		cacheContainer.Caches = nil
		for i := 0; i < len(runLookups); i++ {
			cacheContainer.Caches = append(cacheContainer.Caches, map[string]string{})
		}
	}

	caches := cacheContainer.Caches

	// first pass: walk the collection and see if there's anything we need to look up.
	// if we detect a situation where all the lookups are already satisfied by the cache,
	// then we may not need to do any lookups at all.
	var allKeysToLookup = make([][]string, len(caches)) // preallocate the right number of nils
	for _, item := range collection {
		keys := keySelector(item)
		for i, key := range keys {
			_, ok := caches[i][key]
			if !ok { // we haven't seen this value in the cache, we need to go and look something up
				if allKeysToLookup[i] == nil {
					allKeysToLookup[i] = []string{key}
				} else {
					if !SliceContains(allKeysToLookup[i], key) {
						allKeysToLookup[i] = append(allKeysToLookup[i], key)
					} // else we've already seen this key
				}
			}
		}
	}

	// if we have things we need to look up, go and look them up and insert them into the cache.
	for lookupIdx, keysToLookup := range allKeysToLookup {
		if keysToLookup != nil {
			lookedUpValues, err := runLookups[lookupIdx](keysToLookup)
			if err != nil {
				return nil, err
			}
			for valueIdx, value := range lookedUpValues {
				caches[lookupIdx][keysToLookup[valueIdx]] = value
			}
		}
	}

	// Now we do a second pass over the array in order to produce the output (incorporating the looked-up values from cache)