@ethlete/query 6.0.0-next.20 → 6.0.0-next.21

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @ethlete/query
 
+## 6.0.0-next.21
+
+### Patch Changes
+
+- [#3038](https://github.com/ethlete-io/ethdk/pull/3038) [`0be9397`](https://github.com/ethlete-io/ethdk/commit/0be939765c6074a518c5c05a7110513f1e3e8ef0) Thanks [@TomTomB](https://github.com/TomTomB)! - Fix `ET301` on every legacy interop mutation. `LegacyQuery.execute()` translates v2's single `skipCache` into
+  `allowCache: options.skipCache !== true` for **every** method, so any `legacyPost*` / `legacyPut*` /
+  `legacyPatch*` / `legacyDelete*` executed without an explicit `skipCache: true` reached the repository with
+  `allowCache: true` and threw "This request is uncacheable, but allowCache is set to true".
+
+  `allowCache` is never read on the uncacheable path — there is no cache entry to reuse — so the throw was purely a
+  guard against a mistake in hand-written code. It stays for that, and gains a
+  `silenceUncacheableAllowCacheError` opt-out on `QueryConfig`, which `createLegacyQueryCreator` sets alongside the
+  `silenceMissingWithArgsFeatureError` it already passed. The cache-key guard is unaffected.
+
+  Note that dropping `allowCache: true` in the interop instead would have silently made every legacy `GET` refetch,
+  since an absent `allowCache` means "do not reuse the entry" rather than "use the default".
+
 ## 6.0.0-next.20
 
 ### Minor Changes

package/fesm2022/ethlete-query.mjs

@@ -1014,6 +1014,7 @@ const queryExecute = (options) => {
         previousKey: executeState.previousKey(),
         runQueryOptions,
         isSecure,
+        silenceUncacheableAllowCacheError: queryConfig.silenceUncacheableAllowCacheError,
     });
     executeState.previousKey.set(key);
     state.lastTimeExecutedAt.set(Date.now());
@@ -3401,7 +3402,11 @@ class LegacyQuery {
         this.newQuery.subtle.destroy();
     }
     execute(options = {}) {
-        untracked(() => this.newQuery.execute({ args: this._arguments, options: { allowCache: options.skipCache !== true } }));
+        untracked(() => 
+        // v2 had a single `skipCache` for every method, so this cannot tell whether the underlying request is
+        // cacheable. The creator is built with `silenceUncacheableAllowCacheError`, which makes `allowCache` inert
+        // on a mutation instead of throwing ET301.
+        this.newQuery.execute({ args: this._arguments, options: { allowCache: options.skipCache !== true } }));
         return this;
     }
     abort() {
@@ -3612,6 +3617,8 @@ class LegacyQueryCreator {
                         onlyManualExecution: true,
                         injector,
                         silenceMissingWithArgsFeatureError: true,
+                        // `LegacyQuery.execute()` forwards v2's `skipCache` as `allowCache` for every method, cacheable or not.
+                        silenceUncacheableAllowCacheError: true,
                     });
                     const legacyQuery = new LegacyQuery(newQuery, queryArgs, this.options.entity);
                     if (args?.config?.destroyOnResponse) {
@@ -5723,8 +5730,11 @@ const createQueryRepository = (config) => {
             : shouldCacheQuery(options.method) || creatorOptions?.subtle?.useQueryRepositoryCache === true;
         if (!shouldCache && options.key)
             throw uncacheableRequestHasCacheKeyParam(options.key);
-        if (!shouldCache && runQueryOptions?.allowCache)
+        // `allowCache` is never read on the uncacheable path below — there is no cache entry to reuse — so this throw
+        // is purely a guard against a mistake in hand-written code. The legacy interop opts out of it.
+        if (!shouldCache && runQueryOptions?.allowCache && !options.silenceUncacheableAllowCacheError) {
             throw uncacheableRequestHasAllowCacheParam();
+        }
         const route = buildRoute({
             base: config.baseUrl,
             route: options.route,