Revert "fix: force factory re-execution when tags change"

This reverts commit c6e4758.

Author: Julien-R44

.changeset/rotten-facts-love.md

@@ -173,39 +173,23 @@ export class CacheStack extends BaseDriver {
     return true
   }
 
-  /**
-   * Compare two arrays of tags to check if they are identical
-   *
-   * See https://github.com/Julien-R44/bentocache/issues/83 for more details
-   * about why we need to compare tags.
-   */
-  #areTagsMatching(cachedTags: string[], newTags: string[] = []): boolean {
-    if (cachedTags.length !== newTags?.length) return false
-
-    return cachedTags.every((tag) => newTags.includes(tag))
-  }
-
   /**
    * Check if an item is valid.
    * Valid means :
    * - Logically not expired ( not graced )
    * - Not invalidated by a tag
-   * - Tags match with current options (if provided)
    */
-  isEntryValid(
-    item: GetCacheValueReturn | undefined,
-    options?: { tags?: string[] },
-  ): Promise<boolean> | boolean {
-    if (!item || item.isGraced) return false
+  isEntryValid(item: GetCacheValueReturn | undefined): Promise<boolean> | boolean {
+    if (!item) return false
 
-    const cachedTags = item.entry.getTags()
+    const isGraced = item?.isGraced === true
+    if (isGraced) return false
 
-    if (!this.#areTagsMatching(cachedTags, options?.tags)) return false
-    if (!cachedTags.length) return true
+    if (item.entry.getTags().length === 0) return true
 
-    return this.#tagSystem
-      .isTagInvalidated(item.entry)
-      .then((isTagInvalidated) => !isTagInvalidated)
+    return this.#tagSystem.isTagInvalidated(item.entry).then((isTagInvalidated) => {
+      return !isTagInvalidated
+    })
   }
 
   /**

packages/bentocache/src/cache/cache_stack.ts

@@ -103,7 +103,7 @@ export class SingleTierHandler {
 
     if (!options.forceFresh) {
       remoteItem = await this.stack.l2?.get(key, options)
-      isRemoteItemValid = await this.stack.isEntryValid(remoteItem, options)
+      isRemoteItemValid = await this.stack.isEntryValid(remoteItem)
       if (isRemoteItemValid) {
         return this.#returnRemoteCacheValue(key, remoteItem!, options)
       }
@@ -126,7 +126,7 @@ export class SingleTierHandler {
      */
     if (!options.forceFresh) {
       remoteItem = await this.stack.l2?.get(key, options)
-      isRemoteItemValid = await this.stack.isEntryValid(remoteItem, options)
+      isRemoteItemValid = await this.stack.isEntryValid(remoteItem)
       if (isRemoteItemValid) {
         this.#locks.release(key, releaser)
         return this.#returnRemoteCacheValue(key, remoteItem!, options)

packages/bentocache/src/cache/get_set/single_tier_handler.ts

@@ -125,7 +125,7 @@ export class TwoTierHandler {
        * while we were waiting for the lock.
        */
       localItem = this.stack.l1?.get(key, options)
-      const isLocalItemValid = await this.stack.isEntryValid(localItem, options)
+      const isLocalItemValid = await this.stack.isEntryValid(localItem)
       if (isLocalItemValid) {
         this.#locks.release(key, releaser)
         return this.#returnL1Value(key, localItem!)
@@ -135,7 +135,7 @@ export class TwoTierHandler {
        * Check remote cache in case something was written there
        */
       remoteItem = await this.stack.l2?.get(key, options)
-      const isRemoteItemValid = await this.stack.isEntryValid(remoteItem, options)
+      const isRemoteItemValid = await this.stack.isEntryValid(remoteItem)
       if (isRemoteItemValid) {
         this.#locks.release(key, releaser)
         return this.#returnRemoteCacheValue(key, remoteItem!, options)
@@ -186,7 +186,7 @@ export class TwoTierHandler {
      * returns it without acquiring a lock.
      */
     const localItem = this.stack.l1?.get(key, options)
-    const isLocalItemValid = this.stack.isEntryValid(localItem, options)
+    const isLocalItemValid = this.stack.isEntryValid(localItem)
 
     // A bit nasty, but to keep maximum performance, we avoid async/await here.
     // Let's check for a better way to handle this later.

packages/bentocache/src/cache/get_set/two_tier_handler.ts

@@ -526,74 +526,4 @@ test.group('One tier tests', () => {
     // Original value should still be intact
     assert.equal(await cache.get({ key: 'key1' }), 'initial')
   })
-
-  test('getOrSet() should recalculate value when tags change', async ({ assert }) => {
-    const { cache } = new CacheFactory().withMemoryL1().create()
-
-    let factoryCallCount = 0
-    const factory = () => {
-      factoryCallCount++
-      return `value-${factoryCallCount}`
-    }
-
-    // First call with specific tags
-    const result1 = await cache.getOrSet({
-      key: 'test-key',
-      factory,
-      tags: ['labels', 'settings'],
-      ttl: '5m',
-    })
-
-    assert.equal(result1, 'value-1')
-    assert.equal(factoryCallCount, 1)
-
-    // Second call with same key but different tags
-    // This should trigger the factory again because tags have changed
-    const result2 = await cache.getOrSet({
-      key: 'test-key',
-      factory,
-      tags: ['labels', 'datasets', 'settings'],
-      ttl: '5m',
-    })
-
-    assert.equal(result2, 'value-2')
-    assert.equal(factoryCallCount, 2)
-  })
-
-  test('should be able to deleteByTag if tags changed', async ({ assert }) => {
-    const { cache } = new CacheFactory().withMemoryL1().create()
-
-    let factoryCallCount = 0
-    const factory = () => {
-      factoryCallCount++
-      return `value-${factoryCallCount}`
-    }
-
-    const result1 = await cache.getOrSet({
-      key: 'test-key',
-      factory,
-      tags: ['labels', 'settings'],
-      ttl: '5m',
-    })
-
-    const result2 = await cache.getOrSet({
-      key: 'test-key',
-      factory,
-      tags: ['labels', 'datasets', 'settings'],
-      ttl: '5m',
-    })
-
-    await cache.deleteByTag({ tags: ['datasets'] })
-
-    const result3 = await cache.getOrSet({
-      key: 'test-key',
-      factory,
-      tags: ['labels', 'datasets', 'settings'],
-      ttl: '5m',
-    })
-
-    assert.equal(result1, 'value-1')
-    assert.equal(result2, 'value-2')
-    assert.equal(result3, 'value-3')
-  })
 })

packages/bentocache/tests/cache/one_tier_local.spec.ts

@@ -904,39 +904,4 @@ test.group('Cache', () => {
     assert.equal(l1Value?.entry.getValue(), 'initial')
     assert.equal(l2Value?.entry.getValue(), 'initial')
   })
-
-  test('getOrSet() should recalculate value when tags change in L1+L2 setup', async ({
-    assert,
-  }) => {
-    const { cache } = new CacheFactory().withL1L2Config().create()
-
-    let factoryCallCount = 0
-    const factory = () => {
-      factoryCallCount++
-      return `value-${factoryCallCount}`
-    }
-
-    // First call with specific tags
-    const result1 = await cache.getOrSet({
-      key: 'test-key',
-      factory,
-      tags: ['tag1', 'tag2'],
-      ttl: '5m',
-    })
-
-    assert.equal(result1, 'value-1')
-    assert.equal(factoryCallCount, 1)
-
-    // Second call with same key but different tags
-    // This should trigger the factory again because tags have changed
-    const result2 = await cache.getOrSet({
-      key: 'test-key',
-      factory,
-      tags: ['tag1', 'tag3'],
-      ttl: '5m',
-    })
-
-    assert.equal(result2, 'value-2')
-    assert.equal(factoryCallCount, 2)
-  })
 })