Ability to skip reading the cache in unstable_cache

[michaelschufi]

Goals

1. Skip reading the cache for a specific call.
2. Updating a cached value only if the calculating function does not error.
3. Updating a cached value without any downtime.
4. Updating a cached value in a single step, without needing to have bigger logic branches.

Non-Goals

1. Caching a calculated result at a later time in the same request.

Background

Situation

• In multiple places, we have code to check if a condition is true depending on a calculation, before proceeding.
• The result of the calculation, and the DB query the calculation is dependent on, are cached.
• The calculation result is used in other parts of the code as well.
• Whenever the user wants to update data said DB query is affected by, we need to check if with the newly to-be-saved data, the condition is still true.

How to check and cache?

Before saving
Before saving the new data, we have the following data in the cache/db:

// cache
calculation: 1234
data: v1

// db
data: v1

During the check
We can do the check we need to do in a DB transaction, and act depending on the result.
Data in cache/db during the transaction:

// cache
calculation: 1234
data: v1

// db
- data: v1
+ data: v2-temp

Situation #⁠1 💡: We want to skip reading the cache for the db query and the calculation. (goal #⁠1)

Case 1: Check result: "NOT OK"
In case the data should not be saved (since the check is returned false), the db data is reverted and the cache remains untouched.

// cache
calculation: 1234
data: v1

// db
- data: v2-temp
+ data: v1

Situation #⁠2 💡: We do not want to write into the cache.

Case 2: Check result: "OK"
The data should be saved to the db and the cache updated accordingly.

// cache
- calculation: 1234
+ calculation: 5678
- data: v1
+ data: v2 // not possible in one-go

// db
- data: v2-temp
+ data: v2

Situation #⁠3 💡: We want to write to the cache depending on the result.
Since at the time of the db query, we do not know the calculation result, we cannot cache that (non-goal #⁠1), but the calculation should be cachable right away (goal #⁠2).

Proposal

Proposal

Allow specifying the behaviour of unstable_cache.

Option skipRead
Add an option called skipRead which allows skipping the reading from the cache. It should re-calculate the result to be cached.
Simulating a Cache-MISS so to speak.

Notes

Some thoughts on workarounds (and why they are not ideal).

Not use unstable_cache for the calculation inside the transaction
-> We cannot cache the result to the same key and need to re-run the calculation after commiting the DB transaction.

**Using revalidateTag **
Needs re-running of either the original or the new calculation.

Do something custom
We don't have the other featuers of unstable_cache.