fix(cache): isolate cache keys per provider name and options

Author: sushichan044

src/index.ts

@@ -1,5 +1,5 @@
 import type { Storage } from './cache'
-import type { InitializedProvider, Provider, ResolveFontOptions, ResolveFontResult } from './types'
+import type { InitializedProvider, Provider, ProviderContext, ResolveFontOptions, ResolveFontResult } from './types'
 import { createCachedAsyncStorage, memoryStorage } from './cache'
 
 export * as providers from './providers'
@@ -34,8 +34,12 @@ export const defaultResolveOptions: ResolveFontOptions = {
 
 export async function createUnifont<T extends Provider[]>(providers: T, unifontOptions?: UnifontOptions): Promise<Unifont<T[number]['_name']>> {
   const stack: Record<string, InitializedProvider> = {}
-  const unifontContext = {
-    storage: createCachedAsyncStorage(unifontOptions?.storage ?? memoryStorage()),
+
+  const storageImpl = unifontOptions?.storage ?? memoryStorage()
+  function createProviderAwareStorage(providerName: string, providerOptions: unknown): ProviderContext['storage'] {
+    return createCachedAsyncStorage(storageImpl, {
+      namespace: [providerName, providerOptions],
+    })
   }
 
   // preserve provider order
@@ -46,8 +50,12 @@ export async function createUnifont<T extends Provider[]>(providers: T, unifontO
 
   // initialize all providers in parallel
   await Promise.all(providers.map(async (provider) => {
+    const context: ProviderContext = {
+      storage: createProviderAwareStorage(provider._name, provider._options),
+    }
+
     try {
-      const initializedProvider = await provider(unifontContext)
+      const initializedProvider = await provider(context)
       if (initializedProvider)
         stack[provider._name] = initializedProvider
     }

test/cache.test.ts

@@ -46,9 +46,16 @@ describe('cache storage', () => {
     })
     const unifont = await createUnifont([provider()], { storage: customStorage })
     await unifont.resolveFont('Poppins')
-    expect(customStorage.getItem).toHaveBeenCalledWith('key')
-    expect(customStorage.setItem).toHaveBeenCalledWith('key', expect.objectContaining({ data: 'value' }))
-    expect(customStorage.setItem).toHaveBeenCalledWith('another-key', expect.objectContaining({ data: 'value' }))
+
+    expect(customStorage.getItem).toHaveBeenCalledWith(expect.stringMatching(/key$/))
+    expect(customStorage.setItem).toHaveBeenCalledWith(
+      expect.stringMatching(/key$/),
+      expect.objectContaining({ data: 'value' }),
+    )
+    expect(customStorage.setItem).toHaveBeenCalledWith(
+      expect.stringMatching(/another-key$/),
+      expect.objectContaining({ data: 'value' }),
+    )
   })
 
   describe('keyFragments option', () => {

test/index.test.ts

@@ -165,4 +165,76 @@ describe('unifont', () => {
       await expect(() => unifont.listFonts()).rejects.toThrow()
     })
   })
+
+  describe('cache isolation', () => {
+    it('uses isolated namespace per provider\'s name', async () => {
+      const storage = {
+        getItem: vi.fn(),
+        setItem: vi.fn(),
+      }
+
+      const getProvider = (name: string) =>
+        defineFontProvider(name, async (_options, ctx) => {
+          return {
+            async resolveFont() {
+              await ctx.storage.setItem('key', 'value')
+              return { fonts: [] }
+            },
+          }
+        })()
+
+      const unifontA = await createUnifont([
+        getProvider('provider-A'),
+      ], { storage })
+      const unifontB = await createUnifont([
+        getProvider('provider-B'),
+      ], { storage })
+
+      await unifontA.resolveFont('Poppins')
+      await unifontB.resolveFont('Poppins')
+
+      const providerACacheKey = storage.setItem.mock.calls.at(0)?.at(0) as string | undefined
+      const providerBCacheKey = storage.setItem.mock.calls.at(1)?.at(0) as string | undefined
+
+      expect(storage.setItem).toHaveBeenCalledTimes(2)
+      expect(providerACacheKey).toBeDefined()
+      expect(providerBCacheKey).toBeDefined()
+      expect(providerACacheKey).not.toBe(providerBCacheKey)
+    })
+
+    it('uses isolated namespace per provider\'s options', async () => {
+      const storage = {
+        getItem: vi.fn(),
+        setItem: vi.fn(),
+      }
+
+      const getProvider = (options: { variant: string }) =>
+        defineFontProvider('optioned-provider', async (_options: { variant: string }, ctx) => {
+          return {
+            async resolveFont() {
+              await ctx.storage.setItem('key', 'value')
+              return { fonts: [] }
+            },
+          }
+        })(options)
+
+      const unifontA = await createUnifont([
+        getProvider({ variant: 'A' }),
+      ], { storage })
+      const unifontB = await createUnifont([
+        getProvider({ variant: 'B' }),
+      ], { storage })
+
+      await unifontA.resolveFont('Poppins')
+      await unifontB.resolveFont('Poppins')
+
+      const variantACacheKey = storage.setItem.mock.calls.at(0)?.at(0) as string | undefined
+      const variantBCacheKey = storage.setItem.mock.calls.at(1)?.at(0) as string | undefined
+
+      expect(storage.setItem).toHaveBeenCalledTimes(2)
+      expect(variantACacheKey).toBeDefined()
+      expect(variantBCacheKey).toBeDefined()
+      expect(variantACacheKey).not.toBe(variantBCacheKey)
+    })
+  })
 })