Should advanced cache allow promises?

[mnightingale]

I'm currently experimenting with the new custom cache in 1.0.0-beta.9.

I'll be using it within a react native project and the intention is to download files to disk (I'm currently using Expo FileSystem)

For example the below snippet shows the fetcher takes the props source.uri (like a ImageURISource) which will be a remote https address and the data.source.uri from swr will resolve to a local path to the file.

export type FileInfo = {
  source: {
    uri: string
  }
  // I'll probably be adding other data in here from the headers like ETag that'll later be used with the fetcher
}
const fetcher = async (url: string) => {
  const path = getPathForUrl(url)

  await ensureDirExists()

  return FileSystem.downloadAsync(url, path).then((result) => ({
    source: {
      uri: path,
    },
  }))
}

const CachedImage = ({ source, ...other }: Props): JSX.Element => {
  const { data } = useSWR(source.uri, fetcher, { cache })

  if (data) {
    return <Image source={data.source} {...other} />
  }

  return <></> // There will actually be a placeholder here
}

The next step is I want to create my own cache provider that resolves the local path if it exists before the request has happened, from what I understood I'd want a custom cache provider for this?

So I think as a first draft I want to do something like:

class FileCacheProvider implements Cache<FileInfo> {
  map = new Map()

  async get(key: Key): Promise<FileInfo> | FileInfo | null | undefined {
    if (!this.map.has(key) && typeof key === 'string') {
      const path = getPathForUrl(key)
      const info = await FileSystem.getInfoAsync(path)
      if (info.exists) {
        const result = {
          source: {
            uri: path,
          },
        }
        this.set(key, result)
      }
    }
    return this.map.get(key)
  }
  set(key: Key, value: FileInfo): void {
    this.map.set(key, value)
  }
  delete(key: Key): void {
    this.map.delete(key)
  }
}

const provider = new FileCacheProvider()

const { mutate, cache } = createCache(provider)

But this wont work because the cache doesn't support returning or handling promises.

swr/src/types.ts

Lines 174 to 178 in cb79966

	export interface Cache<Data = any> {
	get(key: Key): Data | null | undefined
	set(key: Key, value: Data): void
	delete(key: Key): void
	}

Eventually I'll want to make options to make the fetcher not fetch if local exists, or send if-none-match headers with the cached ETag (ETag from in-memory cache or local file, I may end up needing persistence of recently used files ion order to clear some of the files).

Is it possible for the cache to handle promises or is their a fundamental reason it doesn't?
Perhaps I'm going about the above solution the wrong way?

Is there any documentation of correct handling of cache keys since I couldn't find any, but I noticed url, $err$url and $req$url calls.

Thanks for reading, superb module.